@rubytech/create-maxy-code 0.1.147 → 0.1.150

package/payload/platform/plugins/admin/hooks/{post-turn-graph-pass.sh → pre-turn-graph-pass.sh}

@@ -1,38 +1,49 @@
 #!/usr/bin/env bash
-# Stop hook — post-turn graph pass. Task 412.
+# UserPromptSubmit hook — pre-turn graph pass. Task 425.
 #
-# Fires on every admin-agent assistant end_turn. Dispatches the
+# Fires once per operator prompt submission. Dispatches the
 # `database-operator` specialist with the full conversation (as
 # `[role: text]` pairs) plus the actual content of every node already
 # written under this `conversationId`. The specialist decides what new
 # graph rows the conversation supports and writes them.
 #
-# No throttle, no idle gate, no recursion-guard transcript grep. The two
-# remaining early exits are doctrinal:
+# Supersedes Task 412's Stop-hook registration. The Stop hook fired on
+# every assistant `end_turn`, including the agent's own ack after the
+# dispatch, producing an unbounded loop. Firing on `UserPromptSubmit`
+# fires once per operator turn and removes the loop primitive entirely.
+# The agent's response to the most recent operator turn is not covered
+# by a per-turn pass until the next operator turn; the
+# `session-end-retrospective.sh` Stop hook walks the full transcript at
+# `/end` and picks up the final assistant reply.
+#
+# The two doctrinal early exits remain:
 #   - MAXY_SESSION_ROLE must equal "admin"  → reason=role-not-admin
 #   - MAXY_SPECIALIST must be empty         → reason=is-specialist
-# (Same `MAXY_SPECIALIST` env-stamp model that blocks the hook from
-# recursing inside a subagent's own stop. The specialist sees the
-# operator's transcript via the dispatch prompt, not via its own PTY.)
-#
-# Duplicate writes between this background pass and the admin agent's
-# discretionary inline `database-operator` dispatch are accepted at
-# write time; cleanup is delegated to the dream-cycle / hygiene sweeps
-# (Tasks 410, 411).
+# `missing-transcript` is retained as a safety exit. `empty-stdin` is
+# dropped — UserPromptSubmit always carries a JSON envelope.
 #
-# Input: Claude Code's Stop hook stdin shape
-#   { "session_id": "<intrinsic>", "transcript_path": "<jsonl path>", ... }
+# Input: Claude Code's UserPromptSubmit hook stdin shape
+#   { "session_id": "<intrinsic>", "transcript_path": "<jsonl path>",
+#     "cwd": "<…>", "hook_event_name": "UserPromptSubmit",
+#     "prompt": "<operator text>" }
+# `prompt` is ignored — the conversation walk reads the JSONL, which
+# already contains the just-submitted user message because
+# UserPromptSubmit fires after the prompt is written.
 #
-# Output: exit 2 + the dispatch directive on stderr per Stop-hook
-# contract. The admin IDENTITY.md "Stop-hook system directives" section
-# binds the agent's response: perform the single Agent dispatch, emit a
-# single-space ack, stop.
+# Output: stdout JSON of the documented UserPromptSubmit shape:
+#   { "hookSpecificOutput": { "hookEventName": "UserPromptSubmit",
+#                              "additionalContext": "<directive body>" } }
+# exit 0. The directive carries the literal token
+# `[system: pre-turn-graph-pass-hook]` so the agent's IDENTITY.md
+# UserPromptSubmit-directive section can distinguish it from operator
+# text. The agent performs the named Task dispatch as a background pass
+# and then continues with its normal response to the operator.
 
 set -uo pipefail
 
 UI_PORT="${MAXY_UI_INTERNAL_PORT:-}"
 if [ -z "$UI_PORT" ]; then
-  echo "[post-turn-graph-pass] trigger-skipped sessionId=unknown reason=missing-env env=MAXY_UI_INTERNAL_PORT" >&2
+  echo "[pre-turn-graph-pass] trigger-skipped sessionId=unknown reason=missing-env env=MAXY_UI_INTERNAL_PORT" >&2
   exit 0
 fi
 UI_BASE="http://127.0.0.1:${UI_PORT}"
@@ -46,7 +57,7 @@ emit_log() {
     --max-time 2 \
     --data "$(python3 -c '
 import sys, json
-print(json.dumps({"tag": "post-turn-graph-pass", "level": "info", "line": sys.argv[1]}))
+print(json.dumps({"tag": "pre-turn-graph-pass", "level": "info", "line": sys.argv[1]}))
 ' "$line")" \
     "$LOG_INGEST_URL" 2>/dev/null || true
 }
@@ -62,14 +73,21 @@ try:
     d = json.load(sys.stdin)
     sid = d.get("session_id", "") or ""
     tpath = d.get("transcript_path", "") or ""
-    print(f"{sid}\t{tpath}")
+    event = d.get("hook_event_name", "") or ""
+    print(f"{sid}\t{tpath}\t{event}")
 except Exception:
-    print("\t")
+    print("\t\t")
 ' 2>/dev/null)
 SESSION_ID="${PARSED%%	*}"
-TRANSCRIPT_PATH="${PARSED#*	}"
+REST="${PARSED#*	}"
+TRANSCRIPT_PATH="${REST%%	*}"
+HOOK_EVENT_NAME="${REST#*	}"
 SESSION_ID_REPORTED="${SESSION_ID:-unknown}"
 
+if [ -n "$HOOK_EVENT_NAME" ] && [ "$HOOK_EVENT_NAME" != "UserPromptSubmit" ]; then
+  emit_log "trigger-skipped sessionId=${SESSION_ID_REPORTED} reason=wrong-hook-event event=${HOOK_EVENT_NAME}"
+  exit 0
+fi
 if [ "${MAXY_SESSION_ROLE:-}" != "admin" ]; then
   emit_log "trigger-skipped sessionId=${SESSION_ID_REPORTED} reason=role-not-admin"
   exit 0
@@ -78,10 +96,6 @@ if [ -n "${MAXY_SPECIALIST:-}" ]; then
   emit_log "trigger-skipped sessionId=${SESSION_ID_REPORTED} reason=is-specialist specialist=${MAXY_SPECIALIST}"
   exit 0
 fi
-if [ -z "$INPUT" ]; then
-  emit_log "trigger-skipped sessionId=${SESSION_ID_REPORTED} reason=empty-stdin"
-  exit 0
-fi
 if [ -z "$SESSION_ID" ] || [ -z "$TRANSCRIPT_PATH" ] || [ ! -f "$TRANSCRIPT_PATH" ]; then
   emit_log "trigger-skipped sessionId=${SESSION_ID_REPORTED} reason=missing-transcript"
   exit 0
@@ -91,9 +105,10 @@ CONVERSATION_ID="${CONVERSATION_NODE_ID:-}"
 
 # Walk the transcript and emit the conversation as `[role: text]` pairs,
 # oldest first. User turns whose only content is `tool_result` blocks are
-# skipped (they carry the Stop-hook feedback envelope and other tool
-# plumbing, not operator intent). Multi-block assistant turns concatenate
-# their `text` blocks; `tool_use` blocks are dropped.
+# skipped (they carry tool plumbing, not operator intent). Multi-block
+# assistant turns concatenate their `text` blocks; `tool_use` blocks are
+# dropped. The just-submitted operator prompt is already present in the
+# JSONL by the time UserPromptSubmit fires.
 CONVERSATION=$(TRANSCRIPT_PATH="$TRANSCRIPT_PATH" python3 - <<'PY'
 import os, json, sys
 
@@ -225,27 +240,42 @@ fi
 
 emit_log "dispatch sessionId=${SESSION_ID} conversationId=${CONVERSATION_ID:-<unset>} conversationTurns=${CONVERSATION_TURNS} priorWritesCount=${PRIOR_WRITES_COUNT} contextBytes=${CONTEXT_BYTES} ms=0"
 
-# Emit the dispatch directive on stderr per Stop-hook contract.
-cat >&2 <<DIRECTIVE
-[system: post-turn-graph-pass-stop-hook]
-Dispatch the database-operator specialist NOW using the Task tool. Do not respond to the operator; this is a background graph-write pass and the operator does not see this turn. After the specialist returns its one-line summary, emit a single space character and stop.
-
-Agent dispatch parameters:
-  subagent_type: database-operator
-  prompt: |
-    accountId: ${ACCOUNT_ID:-<unset>}
-    sessionId: ${SESSION_ID}
-    conversationId: ${CONVERSATION_ID:-<unset>}
-
-    Background post-turn graph pass. Given the conversation below and the list of nodes already written under this conversationId, derive any new graph rows the conversation supports (mentions, ideas, learnings, contacts, tasks — anything the schema admits) and write them. Skip writes the prior list already covers; rely on MERGE semantics for the rest. Return one line in the form: db-op: writes=<n> ms=<n>
-
-    <conversation>
-    ${CONVERSATION}
-    </conversation>
-
-    <prior-writes>
-    ${PRIOR_WRITES}
-    </prior-writes>
-DIRECTIVE
+# Emit the documented UserPromptSubmit JSON envelope on stdout. Python
+# composes the directive body and handles JSON encoding so embedded
+# newlines, quotes, and backslashes in the conversation and prior-writes
+# blocks are escaped correctly.
+ACCOUNT_ID_OUT="${ACCOUNT_ID:-<unset>}" \
+SESSION_ID_OUT="${SESSION_ID}" \
+CONVERSATION_ID_OUT="${CONVERSATION_ID:-<unset>}" \
+CONVERSATION_OUT="${CONVERSATION}" \
+PRIOR_WRITES_OUT="${PRIOR_WRITES}" \
+python3 - <<'PY'
+import os, json, sys
+body = (
+    "[system: pre-turn-graph-pass-hook]\n"
+    "Before responding to the operator, dispatch the database-operator specialist via the Task tool with the parameters below. "
+    "This is a background graph-write pass; do not surface the dispatch in your reply to the operator. "
+    "After the specialist returns its one-line summary, continue with your normal response to the operator's prompt.\n\n"
+    "Agent dispatch parameters:\n"
+    "  subagent_type: database-operator\n"
+    "  prompt: |\n"
+    f"    accountId: {os.environ['ACCOUNT_ID_OUT']}\n"
+    f"    sessionId: {os.environ['SESSION_ID_OUT']}\n"
+    f"    conversationId: {os.environ['CONVERSATION_ID_OUT']}\n\n"
+    "    Background pre-turn graph pass. Given the conversation below and the list of nodes already written under this conversationId, derive any new graph rows the conversation supports (mentions, ideas, learnings, contacts, tasks — anything the schema admits) and write them. Skip writes the prior list already covers; rely on MERGE semantics for the rest. Return one line in the form: db-op: writes=<n> ms=<n>\n\n"
+    "    <conversation>\n"
+    f"    {os.environ['CONVERSATION_OUT']}\n"
+    "    </conversation>\n\n"
+    "    <prior-writes>\n"
+    f"    {os.environ['PRIOR_WRITES_OUT']}\n"
+    "    </prior-writes>\n"
+)
+sys.stdout.write(json.dumps({
+    "hookSpecificOutput": {
+        "hookEventName": "UserPromptSubmit",
+        "additionalContext": body,
+    }
+}))
+PY
 
-exit 2
+exit 0

package/payload/platform/plugins/admin/hooks/session-end-retrospective.sh

@@ -20,7 +20,10 @@
 #
 # Sentinel detection. Completion is recognised by greping the operator's
 # own JSONL (transcript_path on the Stop envelope) for a `tool_use` block
-# whose `name` is exactly `session-retrospective-mark-complete`. The
+# whose `name` is exactly `mcp__admin__session-retrospective-mark-complete`
+# — that is the prefixed form Claude Code writes for MCP tools in the
+# JSONL; the unprefixed name only appears in the operator-facing
+# instruction text below. The
 # sentinel-grep doubles as the re-entry guard: every Stop that fires after
 # the agent's sentinel call sees the sentinel and exits 0 with
 # `gate-released`, so the agent's wrap-up turn never re-blocks.
@@ -128,12 +131,12 @@ fi
 #   1. The latest end-intent token in the most recent real-user message,
 #      or empty if no real user message matches.
 #   2. Whether any `tool_use` block in the transcript names the sentinel
-#      tool `session-retrospective-mark-complete`.
+#      tool `mcp__admin__session-retrospective-mark-complete`.
 # Output one line: <intent-token-or-empty>\t<sentinel-present-yes|no>
 INSPECTION=$(TRANSCRIPT_PATH="$TRANSCRIPT_PATH" python3 - <<'PY'
 import os, json
 
-SENTINEL_TOOL = "session-retrospective-mark-complete"
+SENTINEL_TOOL = "mcp__admin__session-retrospective-mark-complete"
 INTENT_TOKENS = ("/end", "/archive", "end session", "archive this session")
 
 def is_real_user(rec):

package/payload/platform/plugins/docs/references/linkedin-extension.md

@@ -32,7 +32,7 @@ Every click produces **one `:KnowledgeDocument`** keyed on the page URL, holding
 
 Soft signals ("interested in chatting", "would love to compare notes") stay in the document body. They are never promoted to graph nodes.
 
-The plugin will never create `:Communication`, conversation-document `:KnowledgeDocument` rows (i.e. KnowledgeDocument nodes that carry `conversationIdentity`), or `:Message` nodes — those shapes are reserved for other flows (live chat, archive ingest).
+The plugin will never create `:Communication`, `:ConversationArchive` rows (i.e. KnowledgeDocument nodes that carry `conversationIdentity`), or `:Message` nodes — those shapes are reserved for other flows (live chat, archive ingest).
 
 ## When the pill turns amber
 

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

@@ -54,7 +54,7 @@ Roles are installed during setup and listed when {{productName}} introduces itse
 
 {{productName}} maintains a graph database (Neo4j) of everything you've told it. People, conversations, preferences, and context are stored as connected nodes. When you ask {{productName}} something, it searches this graph to retrieve relevant context before responding.
 
-**The recording loop.** Once your turn finishes and the reply is on screen, a Stop hook (`post-turn-graph-pass.sh`) fires the `database-operator` specialist as a background dispatch. The dispatch carries the full conversation as `[role: text]` pairs plus the list of every node already written under this conversation, fetched via `GET /api/admin/post-turn-context`. The specialist decides what new graph rows the conversation supports — mentions of named entities, ideas, learnings, contacts, tasks, anything the schema admits — and writes them. Duplicate writes between this background pass and any inline write the admin agent dispatched mid-turn are accepted and cleaned up by the dream-cycle / hygiene sweeps. There is no throttle and no idle gate: one dispatch per `end_turn`. The admin agent can also dispatch `database-operator` inline at its own discretion when a write must complete before the assistant response ends. To disable the background pass for an account, remove the `post-turn-graph-pass.sh` Stop-hook entry from that account's `~/.<brand>/.claude/settings.json`; there is no toggle.
+**The recording loop.** When you submit a prompt, a UserPromptSubmit hook (`pre-turn-graph-pass.sh`) fires the `database-operator` specialist as a background dispatch before {{productName}} composes its reply. The dispatch carries the full conversation up to and including your just-submitted prompt as `[role: text]` pairs, plus the list of every node already written under this conversation, fetched via `GET /api/admin/post-turn-context`. The specialist decides what new graph rows the conversation supports — mentions of named entities, ideas, learnings, contacts, tasks, anything the schema admits — and writes them. Duplicate writes between this background pass and any inline write the admin agent dispatched mid-turn are accepted and cleaned up by the dream-cycle / hygiene sweeps. One dispatch per operator prompt; the dispatch fires before {{productName}}'s reply and runs in parallel with it. The admin agent can also dispatch `database-operator` inline at its own discretion when a write must complete before the assistant response ends. The final assistant reply of the session is not covered by the per-turn pass (no further operator prompt fires) and is picked up by the `session-end-retrospective.sh` Stop hook when you type `/end`. To disable the background pass for an account, remove the `pre-turn-graph-pass.sh` UserPromptSubmit-hook entry from that account's `~/.<brand>/.claude/settings.json`; there is no toggle.
 
 The memory graph is stored on your Pi. It never leaves your network.
 

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

@@ -40,9 +40,9 @@ These are enabled during onboarding and can be added or removed at any time. Som
 | `linkedin-import` | Import a LinkedIn Basic Data Export — Profile and Connections today, more CSVs as references land | Database operator |
 | `notion-import` | Import a Notion workspace export (markdown + CSV) — pages, databases, hierarchy, attachments, schema-bounded relations, `@person` mentions account-filtered | Database operator |
 | `obsidian-import` | Import an extracted Obsidian vault — pages map to `:KnowledgeDocument`, wikilinks resolve to intra-vault pages or existing entities, tags become `:DefinedTerm`, embedded images become `:DigitalDocument`. Two-phase tool (dry-run → operator disambiguation → commit). | Database operator |
-| `x-import` | Import an X (Twitter) Basic Data Export — tweet stream renders as one chronological transcript and ingests as a single `:KnowledgeDocument` (`source='x'`); each DM `conversationId` ingests as one conversation-document `:KnowledgeDocument` (`source='x-dm'`, keyed on `conversationIdentity`) via `conversation-archive-ingest.sh`. Mentions, replies, and quote-tweet authors resolve to `:Person` on lowercased `xHandle`; every handle and DM senderId confirms against existing nodes (no auto-create). Per-thread KD granularity and `:Post` / `:DirectMessage` labels are explicitly rejected. | Database operator |
+| `x-import` | Import an X (Twitter) Basic Data Export — tweet stream renders as one chronological transcript and ingests as a single `:KnowledgeDocument` (`source='x'`); each DM `conversationId` ingests as one `:ConversationArchive` (`source='x-dm'`, keyed on `conversationIdentity`) via `conversation-archive-ingest.sh`. Mentions, replies, and quote-tweet authors resolve to `:Person` on lowercased `xHandle`; every handle and DM senderId confirms against existing nodes (no auto-create). Per-thread KD granularity and `:Post` / `:DirectMessage` labels are explicitly rejected. | Database operator |
 | `memory/skills/conversation-archive` | Source-agnostic conversation transcript ingest. One skill for WhatsApp `_chat.txt`, Telegram, Signal, LinkedIn DMs, Zoom transcript, meeting minutes, iMessage, Slack, X DMs — `--source <enum>` selects the per-source normaliser. Single Bash entry — `bash platform/plugins/memory/bin/conversation-archive-ingest.sh <archive> --source <enum> --owner-element-id <id> --participant-person-ids <csv> --scope <admin\|public>` — runs normalise → operator-confirms owner + every distinct sender → sessionize at gap-hours boundaries (default 12h) → classify each session via Haiku (`memory-classify` with `mode='chat'`) into topic-bounded `:Section` chunks → memory-ingest with `conversationIdentity` set (writes `:KnowledgeDocument`), `source=<enum>`. Re-imports are delta-append. Auto-creating participants is forbidden — any sender outside the operator-confirmed closed set LOUD-FAILs with `parser-miss`. Distinct from the live `whatsapp` plugin (Baileys). | Database operator |
-| `memory/skills/conversation-archive-enrich` | Phase 2 for any named conversation-document `:KnowledgeDocument` — source-agnostic per-row insight derivation. Operator-triggered (never auto-fires on Phase 1 completion). Walks the parent's `:Section` chunks in pages via the read-only MCP tool `mcp__memory__conversation-archive-derive-insights`; surfaces high-confidence claims for per-row operator gate (`wire / skip / reject`) over four kinds — `mention`, `task`, `preference`, `observed-relationship`. Idempotent on `(elementId(chunk), kind, contentHash)` — re-runs collapse identical claims. Haiku runs on OAuth (admin-side LLM never the API key); confidence floor is a hedging-avoidance instruction in the system prompt, not a numeric post-filter. | Database operator |
+| `memory/skills/conversation-archive-enrich` | Phase 2 for any named `:ConversationArchive` — source-agnostic per-row insight derivation. Operator-triggered (never auto-fires on Phase 1 completion). Walks the parent's `:Section` chunks in pages via the read-only MCP tool `mcp__memory__conversation-archive-derive-insights`; surfaces high-confidence claims for per-row operator gate (`wire / skip / reject`) over four kinds — `mention`, `task`, `preference`, `observed-relationship`. Idempotent on `(elementId(chunk), kind, contentHash)` — re-runs collapse identical claims. Haiku runs on OAuth (admin-side LLM never the API key); confidence floor is a hedging-avoidance instruction in the system prompt, not a numeric post-filter. | Database operator |
 
 ### Claude Official (marketplace)
 

package/payload/platform/plugins/linkedin-import/skills/linkedin-import/SKILL.md

@@ -55,7 +55,7 @@ When the owner is an external Person (non-operator archive), the anchor is the c
    - LinkedIn skills → `:DefinedTerm` with `category: 'linkedin-skill'`.
    - LinkedIn articles → `:CreativeWork` with `category: 'linkedin-article'`.
    - LinkedIn recommendations → `:Review`.
-   - LinkedIn DMs → `:Message:LinkedInMessage` + `:Conversation:LinkedInConversation` (sublabels on the existing labels).
+   - LinkedIn DMs → routed to the `conversation-archive` skill (Task 397) as a `--source linkedin-messages` invocation. Each DM thread becomes one `:ConversationArchive` parent with `:Section` chunks; no bespoke LinkedIn sublabels.
    - Certifications → `:Credential` (genuinely new — no existing {{productName}} label fits `schema:EducationalOccupationalCredential`).
 5. **Schema-base property names.** `givenName` / `familyName` / `telephone` / `dateSent` — not `firstName` / `phone` / `sentAt`. See [`platform/plugins/memory/references/schema-base.md`](../../../../plugins/memory/references/schema-base.md).
 6. **Schema-base edge names.** `(:Person)-[:WORKS_FOR]->(:Organization)` for positions. Custom LinkedIn edges (`CONNECTED_ON_LINKEDIN`, `ENDORSED`) only where schema-base has no canonical name.
@@ -116,10 +116,10 @@ Each entry maps to exactly one reference. Order reflects when a reference's edge
 | 6 | `Company Follows.csv` | _pending_ | `(:AdminUser)-[:FOLLOWS {since}]->(:Organization)` |
 | 6 | `Causes You Care About.csv` | _pending_ | `(:UserProfile)-[:SUPPORTS]->(:DefinedTerm {category:'cause'})` |
 | 6 | `Events.csv` | _pending_ | `(:AdminUser)-[:ATTENDED_EVENT]->(:Event)` |
-| 7 | `messages.csv` | _pending_ | `:Conversation:LinkedInConversation` + threaded `:Message:LinkedInMessage` + `(:Person)-[:PARTICIPANT_IN]->(conv)` |
-| 7 | `guide_messages.csv` | _pending_ | same (likely empty) |
-| 7 | `learning_coach_messages.csv` | _pending_ | same (likely empty) |
-| 7 | `learning_role_play_messages.csv` | _pending_ | same (likely empty) |
+| 7 | `messages.csv` | conversation-archive (Task 397) | dispatched to `conversation-archive` skill with `--source linkedin-messages`; one `:ConversationArchive` per DM thread + `:Section` chunks + `(:Person)-[:PARTICIPANT_IN]->(archive)` |
+| 7 | `guide_messages.csv` | same | same dispatch (likely empty) |
+| 7 | `learning_coach_messages.csv` | same | same dispatch (likely empty) |
+| 7 | `learning_role_play_messages.csv` | same | same dispatch (likely empty) |
 | 8 | `Articles/` | _pending_ | `(:AdminUser)-[:AUTHORED]->(:CreativeWork {category:'linkedin-article'})` |
 | 8 | `Learning.csv` | _pending_ | `(:UserProfile)-[:COMPLETED]->(:Credential)` (LinkedIn Learning courses) |
 | 9 | `Jobs/Job Applications.csv` | _pending_ | `(:AdminUser)-[:APPLIED_TO {date}]->(:Organization)` via job-posting text on the edge |

package/payload/platform/plugins/memory/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memory",
-  "description": "Graph memory plugin. Provides memory-search (with optional `fields` projection for known-shape lookups), memory-rank, memory-write, memory-update, and the :Report surface (memory-report-write / memory-report-read-latest / memory-report-list) for reading from, writing to, and updating the Neo4j knowledge graph. Includes conversational memory — organic preference learning, evidence-backed recall, and transparent 'what do you know about me?' responses. Document ingestion (memory-classify + memory-ingest) supports two modes: `document` (default) for unstructured PDF/web content → :KnowledgeDocument (keyed on `attachmentId`) + :Section, and `chat` for conversation transcripts → :KnowledgeDocument (keyed on `conversationIdentity`) + :Section chunks; one parent label, two writer paths chosen by which identity property is set. Conversation-archive Phase 2 (`conversation-archive-derive-insights`) walks chunks of one named archive and emits per-row claim proposals for operator-gated wiring; `conversation-archive-enrich-rejection` records (or undoes) durable per-row rejections so already-triaged claims do not re-surface on re-runs. Ships four skills: `conversational-memory`, `document-ingest`, `conversation-archive` (source-agnostic transcript ingest for WhatsApp, Telegram, Signal, LinkedIn DMs, Zoom, meeting minutes, iMessage, Slack), and `conversation-archive-enrich` (per-row operator-gated insight derivation over a named archive's chunks).",
+  "description": "Graph memory plugin. Provides memory-search (with optional `fields` projection for known-shape lookups), memory-rank, memory-write, memory-update, and the :Report surface (memory-report-write / memory-report-read-latest / memory-report-list) for reading from, writing to, and updating the Neo4j knowledge graph. Includes conversational memory — organic preference learning, evidence-backed recall, and transparent 'what do you know about me?' responses. Document ingestion (memory-classify + memory-ingest) supports two modes: `document` (default) for unstructured PDF/web content → :KnowledgeDocument (keyed on `attachmentId`) + :Section, and `chat` for conversation transcripts → :ConversationArchive (Task 397, keyed on `conversationIdentity`) + :Section chunks; two parent labels, two writer paths chosen by which identity property is set. Conversation-archive Phase 2 (`conversation-archive-derive-insights`) walks chunks of one named archive and emits per-row claim proposals for operator-gated wiring; `conversation-archive-enrich-rejection` records (or undoes) durable per-row rejections so already-triaged claims do not re-surface on re-runs. Ships four skills: `conversational-memory`, `document-ingest`, `conversation-archive` (source-agnostic transcript ingest for WhatsApp, Telegram, Signal, LinkedIn DMs, Zoom, meeting minutes, iMessage, Slack), and `conversation-archive-enrich` (per-row operator-gated insight derivation over a named archive's chunks).",
   "version": "0.1.0",
   "author": {
     "name": "Rubytech LLC"

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

@@ -1,6 +1,6 @@
 ---
 name: memory
-description: "Graph memory plugin. Provides memory-search (with optional `fields` projection for known-shape lookups), memory-rank, memory-write, memory-update, and the :Report surface (memory-report-write / memory-report-read-latest / memory-report-list) for reading from, writing to, and updating the Neo4j knowledge graph. Includes conversational memory — organic preference learning, evidence-backed recall, and transparent 'what do you know about me?' responses. Document ingestion (memory-classify + memory-ingest) supports two modes: `document` (default) for unstructured PDF/web content → :KnowledgeDocument (keyed on `attachmentId`) + :Section, and `chat` for conversation transcripts → :KnowledgeDocument (keyed on `conversationIdentity`) + :Section chunks; one parent label, two writer paths chosen by which identity property is set. Conversation-archive Phase 2 (`conversation-archive-derive-insights`) walks chunks of one named archive and emits per-row claim proposals for operator-gated wiring; `conversation-archive-enrich-rejection` records (or undoes) durable per-row rejections so already-triaged claims do not re-surface on re-runs. Ships four skills: `conversational-memory`, `document-ingest`, `conversation-archive` (source-agnostic transcript ingest for WhatsApp, Telegram, Signal, LinkedIn DMs, Zoom, meeting minutes, iMessage, Slack), and `conversation-archive-enrich` (per-row operator-gated insight derivation over a named archive's chunks)."
+description: "Graph memory plugin. Provides memory-search (with optional `fields` projection for known-shape lookups), memory-rank, memory-write, memory-update, and the :Report surface (memory-report-write / memory-report-read-latest / memory-report-list) for reading from, writing to, and updating the Neo4j knowledge graph. Includes conversational memory — organic preference learning, evidence-backed recall, and transparent 'what do you know about me?' responses. Document ingestion (memory-classify + memory-ingest) supports two modes: `document` (default) for unstructured PDF/web content → :KnowledgeDocument (keyed on `attachmentId`) + :Section, and `chat` for conversation transcripts → :ConversationArchive (Task 397, keyed on `conversationIdentity`) + :Section chunks; two parent labels, two writer paths chosen by which identity property is set. Conversation-archive Phase 2 (`conversation-archive-derive-insights`) walks chunks of one named archive and emits per-row claim proposals for operator-gated wiring; `conversation-archive-enrich-rejection` records (or undoes) durable per-row rejections so already-triaged claims do not re-surface on re-runs. Ships four skills: `conversational-memory`, `document-ingest`, `conversation-archive` (source-agnostic transcript ingest for WhatsApp, Telegram, Signal, LinkedIn DMs, Zoom, meeting minutes, iMessage, Slack), and `conversation-archive-enrich` (per-row operator-gated insight derivation over a named archive's chunks)."
 tools:
   - name: memory-search
     publicAllowlist: true
@@ -160,7 +160,7 @@ Use `expandHops: 0` for listing and inventory queries (returns node properties o
 
 ## Hierarchy
 
-Every node in the graph sits under a parent in the canonical chain `LocalBusiness → Project → Task | Person | Organisation | KnowledgeDocument`. `memory-write` and `memory-ingest` require the caller to name the parent (an `elementId` for the resolved parent node) and refuse the write if the parent does not exist or is at the wrong level of the chain. Specialists author the parent resolution — typically via `memory-search` against the brief — before invoking the write. Cross-hierarchy edges (a `:Person` linked to several Projects, a `:KnowledgeDocument` about several Organisations) are normal and are added as separate `memory-write` calls; the hierarchy rule governs the containment edge that anchors the node, not the additional cross-edges that describe what the node relates to.
+Every node in the graph sits under a parent in the canonical chain `LocalBusiness → Project → Task | Person | Organisation | KnowledgeDocument | ConversationArchive` (Task 397 promoted `:ConversationArchive` to a peer parent). `memory-write` and `memory-ingest` require the caller to name the parent (an `elementId` for the resolved parent node) and refuse the write if the parent does not exist or is at the wrong level of the chain. Specialists author the parent resolution — typically via `memory-search` against the brief — before invoking the write. Cross-hierarchy edges (a `:Person` linked to several Projects, a `:KnowledgeDocument` or `:ConversationArchive` about several Organisations) are normal and are added as separate `memory-write` calls; the hierarchy rule governs the containment edge that anchors the node, not the additional cross-edges that describe what the node relates to.
 
 ## Anchoring writes to provenance — `producedByTaskId` and the conversation env-stamp
 
@@ -182,7 +182,7 @@ Graph hygiene is **agent-directed, case by case** — no autonomous rule engine,
 **Conversation-level expunge.**
 - `conversation-memory-expunge` — agent-invoked, scoped to one conversation. Scrubs a specified substring from every linked `:Memory` node's string properties with audit. Transcript Message nodes are immutable history and are never modified — only the derived `:Memory` payload that subsequent `memory-search` would re-surface.
 
-**Single-node removal.** Use `memory-delete` by `elementId`. The node is marked `:Trashed` (relationships preserved, invisible to `memory-search` and any read filtered via `notTrashed`). For `KnowledgeDocument`, the trash cascades to linked `Section` and `Chunk` children. Restore via `memory-restore` (fails loudly when an active node already holds a unique slot the trashed one needs back). Hard removal happens later via `memory-empty-trash` after the grace period (default 30 days). GDPR cascades go through `contact-erase` (per Art. 17) — that bypasses the trash primitive deliberately. There is no bulk delete-by-shape.
+**Single-node removal.** Use `memory-delete` by `elementId`. The node is marked `:Trashed` (relationships preserved, invisible to `memory-search` and any read filtered via `notTrashed`). For `KnowledgeDocument` and `ConversationArchive` (Task 397), the trash cascades to linked `Section` and `Chunk` children. Restore via `memory-restore` (fails loudly when an active node already holds a unique slot the trashed one needs back). Hard removal happens later via `memory-empty-trash` after the grace period (default 30 days). GDPR cascades go through `contact-erase` (per Art. 17) — that bypasses the trash primitive deliberately. There is no bulk delete-by-shape.
 
 **Why soft-delete.** On 2026-04-20 an autonomous orphan-delete rule wiped 19 nodes in one `graph-prune-run` call; properties were unrecoverable (Neo4j Community has no PITR, no APOC). The cron, the `graph-prune-run` tool, and the rule engine have been removed. An earlier fix added the `:Trashed` label primitive so every soft-delete caller (`memory-delete`, `contact-delete`, the admin `/graph` page's trash button) runs the same shared `trashNode` helper — relationships preserved, unique keys snapshotted into `_trashedKeys`, audit lines `[trash:marked] by=<surface>` for cross-cut provenance.
 
@@ -192,7 +192,7 @@ Graph hygiene is **agent-directed, case by case** — no autonomous rule engine,
 
 ## Brain-capture diagnostic — `memory-signals-recent`
 
-Read-only window into the extractive graph writes produced under this account. Returns recent `:MENTIONS` edges (`:Message-[:MENTIONS]->Entity`) and `:Idea` nodes interleaved by `observedAt`. Default window is 24 hours; pass `windowHours` (max 720) and `limit` (max 200) to scan a longer arc. Use this when the operator asks "what has the brain captured today?", "show me recent mentions of X", or "what ideas did I leave on the table this week?". Writes are produced by `database-operator`, either inline at admin discretion or via the once-per-turn background pass (`platform/plugins/admin/hooks/post-turn-graph-pass.sh`, Task 412 — supersedes the original `signal-detector` specialist + throttled hook from Task 303).
+Read-only window into the extractive graph writes produced under this account. Returns recent `:MENTIONS` edges (`:Message-[:MENTIONS]->Entity`) and `:Idea` nodes interleaved by `observedAt`. Default window is 24 hours; pass `windowHours` (max 720) and `limit` (max 200) to scan a longer arc. Use this when the operator asks "what has the brain captured today?", "show me recent mentions of X", or "what ideas did I leave on the table this week?". Writes are produced by `database-operator`, either inline at admin discretion or via the once-per-operator-prompt background pass (`platform/plugins/admin/hooks/pre-turn-graph-pass.sh`, Task 425 — supersedes the Task 412 Stop-hook variant of the same logic, which itself superseded the original `signal-detector` specialist + throttled hook from Task 303).
 
 ## Conversational Memory
 

package/payload/platform/plugins/memory/bin/conversation-archive-ingest.mjs

@@ -9,7 +9,7 @@
 // `--source <enum>` selects the normaliser at the top of the pipeline:
 //
 //   normalise  → bind canonical senders → derive conversationIdentity
-//   → look up prior conversation-document :KnowledgeDocument (delta cursor)
+//   → look up prior :ConversationArchive (delta cursor)
 //   → sessionize delta at gap-hours boundaries
 //   → for each session: classify (mode='chat') → memoryIngest immediately
 //                       → advance lastIngestedMessageHash + lastIngestedMessageAt
@@ -319,7 +319,7 @@ function findChatTxt(dir) {
 // The title is computed once per ingest from inputs that are immutable for
 // the conversation (source, accountId, sortedParticipantElementIds, archive
 // dateRange) so re-ingests produce the same string. Memory-ingest writes it
-// to the conversation-document `:KnowledgeDocument.title` ON CREATE and COALESCE-on-MATCH so the UI
+// to the `:ConversationArchive.title` ON CREATE and COALESCE-on-MATCH so the UI
 // (display-helpers.ts) reads a stable label without ever falling through to
 // `summary`. Per-session counter strings stay in the progress file only.
 //
@@ -555,7 +555,7 @@ async function main() {
 
   // 6c. Verify participant elementIds resolve to graph nodes with the right
   // accountId and labels. Per-line senderName binding is gone;
-  // operator-confirmed participants attach to the conversation-document :KnowledgeDocument parent.
+  // operator-confirmed participants attach to the :ConversationArchive parent.
   let session = getSession();
   try {
     await verifyParticipantElementIds({
@@ -574,7 +574,7 @@ async function main() {
     fail("argv", { reason: err instanceof Error ? err.message : String(err) });
   }
 
-  // 6d. Derive conversationIdentity and look up the prior conversation-document parent (:KnowledgeDocument with this conversationIdentity).
+  // 6d. Derive conversationIdentity and look up the prior :ConversationArchive parent (Task 397).
   // sub-scope B — under `--rebuild` we skip the prior-cursor lookup
   // entirely; the run is treated as first-ingest, the first session cleans
   // prior chunks (cleanupPriorChunks=true), and the cursor is overwritten
@@ -590,7 +590,7 @@ async function main() {
   if (!rebuild) {
     try {
       const r = await session.run(
-        `MATCH (a:KnowledgeDocument { conversationIdentity: $cid })
+        `MATCH (a:ConversationArchive { conversationIdentity: $cid })
          OPTIONAL MATCH (a)-[:HAS_SECTION]->(c:Section { archiveSha256: $sha })
          RETURN elementId(a) AS elemId,
                 a.lastIngestedMessageHash AS lastHash,

package/payload/platform/plugins/memory/bin/conversation-archive-ingest.sh

@@ -9,7 +9,7 @@
 # the same pipeline with `--source` selecting the normaliser.
 #
 # Pipeline: normalise (per source) → bind canonical sender set →
-# derive conversationIdentity → look up prior conversation-document :KnowledgeDocument (delta
+# derive conversationIdentity → look up prior :ConversationArchive (delta
 # cursor) → sessionize delta at gap-hours boundary → for each session: classify
 # via Haiku (mode='chat') + memory-ingest immediately (per-session checkpoint).
 #

package/payload/platform/plugins/memory/mcp/dist/index.js

@@ -17,10 +17,10 @@ import { memoryArchiveWrite } from "./tools/memory-archive-write.js";
 import { obsidianVaultImport, } from "./tools/obsidian-vault-import.js";
 // whatsapp-export-{parse,preview,insight-write} deleted. Conversation
 // transcripts now flow through the source-agnostic `conversation-archive` skill
-// + `memory/bin/conversation-archive-ingest.sh`, writing :KnowledgeDocument
-// (keyed on `conversationIdentity`) + :Section chunks via memory-ingest. The
-// writer dispatches on the presence of `conversationIdentity` rather than a
-// parent-label discriminator.
+// + `memory/bin/conversation-archive-ingest.sh`, writing :ConversationArchive
+// (Task 397 — keyed on `conversationIdentity`) + :Section chunks via
+// memory-ingest. The writer dispatches on the presence of
+// `conversationIdentity`; the parent label tracks the dispatch.
 // whatsapp-export-insight-pass deleted (Phase 2 deferred).
 import { memoryIngestWeb } from "./tools/memory-ingest-web.js";
 import { memoryClassify } from "./tools/memory-classify.js";
@@ -460,18 +460,18 @@ eagerTool(server, "memory-rank", "Retrieve entities from the knowledge graph and
 });
 // ---------------------------------------------------------------------------
 // conversation-archive Phase 2: chunk-anchored insight derivation.
-// Read-only tool. Walks the :Section chunks of one named conversation-document
-// (`:KnowledgeDocument` with `conversationIdentity` set) in pages and asks
-// Haiku (via OAuth) for the high-confidence claims. Returns operator-facing
-// proposals with the cypher needed to wire them; the conversation-archive-
-// enrich skill drives the per-row operator gate. The tool itself NEVER
-// writes; idempotency lives on the MERGE-key shape (chunkElementId, kind,
-// contentHash) encoded in each proposal's mergeCypher.
+// Read-only tool. Walks the :Section chunks of one named conversation
+// archive (`:ConversationArchive` keyed on `conversationIdentity` — Task
+// 397) in pages and asks Haiku (via OAuth) for the high-confidence claims.
+// Returns operator-facing proposals with the cypher needed to wire them;
+// the conversation-archive-enrich skill drives the per-row operator gate.
+// The tool itself NEVER writes; idempotency lives on the MERGE-key shape
+// (chunkElementId, kind, contentHash) encoded in each proposal's mergeCypher.
 // ---------------------------------------------------------------------------
-server.tool("conversation-archive-derive-insights", "Walk the :Section chunks of one named conversation-document (:KnowledgeDocument with conversationIdentity set) and emit high-confidence claim proposals (mention, task, preference, observed-relationship). Read-only: the caller drives a per-row operator gate; this tool never writes. Paginates via chunkOffset + chunkLimit (default 5). Operator-triggered, never automatic.", {
+server.tool("conversation-archive-derive-insights", "Walk the :Section chunks of one named :ConversationArchive (conversation-archive walker) and emit high-confidence claim proposals (mention, task, preference, observed-relationship). Read-only: the caller drives a per-row operator gate; this tool never writes. Paginates via chunkOffset + chunkLimit (default 5). Operator-triggered, never automatic.", {
     archiveElementId: z
         .string()
-        .describe("elementId of the conversation-document parent (:KnowledgeDocument with conversationIdentity) the operator named (required)."),
+        .describe("elementId of the :ConversationArchive parent (Task 397 — keyed on conversationIdentity) the operator named (required)."),
     chunkOffset: z
         .number()
         .int()
@@ -866,11 +866,11 @@ if (!readOnly) {
             };
         }
     });
-    server.tool("memory-update", "Update properties on an existing node in the knowledge graph. Finds the node by element ID, verifies account ownership, sets the provided properties, and recomputes the embedding. For :Person / :Organization / :Concept / :Project / :LocalBusiness, pass rewriteCompiledTruth=true to recompute the admin compiledTruth summary; when the label is in the public-twin set (:Organization / :Concept / :Project / :LocalBusiness) and the admin pass changes the truth, the public-twin compiledTruthPublic auto-rewrites in the same call. Pass compiledTruthPublic to override the public twin directly via chat. Direct writes to compiledTruth / compiledTruthUpdatedAt / compiledTruthSource / compiledTruthPublic / compiledTruthPublicUpdatedAt / compiledTruthPublicSource via the properties bag are refused — use the dedicated arguments.", {
+    server.tool("memory-update", "Update properties on an existing node in the knowledge graph. Finds the node by element ID, verifies account ownership, sets the provided properties, and recomputes the embedding. For :Person / :Organization / :Concept / :Project / :LocalBusiness, pass rewriteCompiledTruth=true to recompute the admin compiledTruth summary; when the label is in the public-twin set (:Organization / :Concept / :Project / :LocalBusiness) and the admin pass changes the truth, the public-twin compiledTruthPublic auto-rewrites in the same call. Pair rewriteCompiledTruth=true with operatorHint to feed the rewriter an operator correction from chat for the admin twin — the resulting write is stamped compiledTruthSource='operator', the 7-day cooldown does not block it, and the public-twin auto-fire is skipped. Pair rewriteCompiledTruth=true with publicOperatorHint to do the same for the public twin — the public rewriter is invoked with the hint folded into the public-mode prompt regardless of whether the admin pass changed the truth, the public-cooldown is bypassed, and the write is stamped compiledTruthPublicSource='operator'. Direct writes to compiledTruth / compiledTruthUpdatedAt / compiledTruthSource / compiledTruthPublic / compiledTruthPublicUpdatedAt / compiledTruthPublicSource via the properties bag are refused — the rewriter is the only writer.", {
         nodeId: z.string().describe("Element ID of the node to update (from memory-search results)"),
         properties: z
             .record(z.string(), z.unknown())
-            .describe("Properties to set or overwrite. Restricted keys (embedding, accountId, createdAt) are ignored. Compiled-truth fields are system-managed and rejected loudly here — use rewriteCompiledTruth or the compiledTruthPublic argument."),
+            .describe("Properties to set or overwrite. Restricted keys (embedding, accountId, createdAt) are ignored. Compiled-truth fields are system-managed and rejected loudly here — use rewriteCompiledTruth (optionally with operatorHint or publicOperatorHint)."),
         rewriteCompiledTruth: z
             .boolean()
             .optional()
@@ -879,11 +879,15 @@ if (!readOnly) {
             .boolean()
             .optional()
             .describe("Bypass the 7-day cooldown that protects operator-edited compiledTruth and compiledTruthPublic fields from automatic rewriter passes. Set only when the operator explicitly asks for a refresh."),
-        compiledTruthPublic: z
+        operatorHint: z
             .string()
             .optional()
-            .describe("Operator override for the public-facing compiled-truth twin. Writes the supplied string verbatim, stamps source='operator', and resets the public-twin cooldown. Length cap: 2000 characters. Only valid on :Organization / :Concept / :Project / :LocalBusiness (:Person has no public twin)."),
-    }, async ({ nodeId, properties, rewriteCompiledTruth, forceRewrite, compiledTruthPublic }) => {
+            .describe("Operator correction for the admin twin, supplied via chat. Only valid with rewriteCompiledTruth=true. Folded into the rewriter prompt with precedence over the timeline; the resulting write is stamped compiledTruthSource='operator', the 7-day cooldown does not block this pass, and the public-twin auto-fire is skipped so admin-side corrections do not leak unreviewed to the public surface. Cap: 1000 characters."),
+        publicOperatorHint: z
+            .string()
+            .optional()
+            .describe("Operator correction for the public twin, supplied via chat. Only valid with rewriteCompiledTruth=true AND a public-twin label (:Organization / :Concept / :Project / :LocalBusiness — :Person has no public twin). Folded into the public-mode rewriter prompt with precedence over the timeline; the public rewriter fires regardless of whether the admin pass changed the truth, the public-cooldown is bypassed, and the write is stamped compiledTruthPublicSource='operator'. Cap: 1000 characters."),
+    }, async ({ nodeId, properties, rewriteCompiledTruth, forceRewrite, operatorHint, publicOperatorHint }) => {
         if (!accountId)
             return refuseNoAccount("memory-update");
         try {
@@ -898,13 +902,15 @@ if (!readOnly) {
                 },
                 rewriteCompiledTruth,
                 forceRewrite,
-                compiledTruthPublic,
+                operatorHint,
+                publicOperatorHint,
             });
             const rewriterLine = (() => {
                 if (!result.rewriter)
                     return "";
                 if (result.rewriter.kind === "ok") {
-                    return `\nAdmin compiled-truth rewritten: ${result.rewriter.charsBefore} → ${result.rewriter.charsAfter} chars.`;
+                    const sourceFragment = result.rewriter.source === "operator" ? " (operator-attributed)" : "";
+                    return `\nAdmin compiled-truth rewritten${sourceFragment}: ${result.rewriter.charsBefore} → ${result.rewriter.charsAfter} chars.`;
                 }
                 if (result.rewriter.kind === "refused") {
                     return result.rewriter.reason === "operator-edit-cooldown"
@@ -920,7 +926,8 @@ if (!readOnly) {
                 if (!result.publicRewriter)
                     return "";
                 if (result.publicRewriter.kind === "ok") {
-                    return `\nPublic compiled-truth rewritten: ${result.publicRewriter.charsBefore} → ${result.publicRewriter.charsAfter} chars.`;
+                    const sourceFragment = result.publicRewriter.source === "operator" ? " (operator-attributed)" : "";
+                    return `\nPublic compiled-truth rewritten${sourceFragment}: ${result.publicRewriter.charsBefore} → ${result.publicRewriter.charsAfter} chars.`;
                 }
                 if (result.publicRewriter.kind === "refused") {
                     return result.publicRewriter.reason === "operator-edit-cooldown"
@@ -932,21 +939,11 @@ if (!readOnly) {
                 }
                 return `\nPublic rewriter LLM call failed (cause=${result.publicRewriter.cause}); compiledTruthPublic unchanged.`;
             })();
-            const overrideLine = (() => {
-                if (!result.publicOverride)
-                    return "";
-                if (result.publicOverride.kind === "applied") {
-                    return `\ncompiledTruthPublic overridden by operator: ${result.publicOverride.chars} chars.`;
-                }
-                return result.publicOverride.reason === "wrong-label"
-                    ? `\ncompiledTruthPublic override refused: label is not in the public-twin set (:Organization / :Concept / :Project / :LocalBusiness).`
-                    : `\ncompiledTruthPublic override refused: exceeds 2000 character cap.`;
-            })();
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Node updated: [${result.labels.join(", ")}] (ID: ${result.nodeId})${rewriterLine}${publicRewriterLine}${overrideLine}`,
+                        text: `Node updated: [${result.labels.join(", ")}] (ID: ${result.nodeId})${rewriterLine}${publicRewriterLine}`,
                     },
                 ],
             };
@@ -1256,7 +1253,7 @@ if (!readOnly) {
         "raw Cypher. Use ONLY for flat first-class entity exports (LinkedIn Connections.csv and " +
         "future CRM-type seeds). Conversation transcripts (WhatsApp, Telegram, Signal, …) flow " +
         "through the `conversation-archive` skill (memory/bin/conversation-archive-ingest.sh) " +
-        "instead, which writes :KnowledgeDocument (keyed on conversationIdentity) + :Section chunks via memory-ingest. " +
+        "instead, which writes :ConversationArchive (Task 397 — keyed on conversationIdentity) + :Section chunks via memory-ingest. " +
         "Currently supported archiveType values: `linkedin-connections`, `obsidian-vault` (invoked indirectly by the obsidian-import skill via the obsidian-vault-import tool).", {
         archiveType: z
             .enum(["linkedin-connections", "obsidian-vault"])
@@ -2348,6 +2345,11 @@ server.tool("memory-typed-edge-pass", "Run the typed-edge auto-extraction pass o
         return refuseNoAccount("memory-typed-edge-pass");
     const dbSession = getSession();
     try {
+        // Cast: the McpServer instance is `any`-typed at the module level (see
+        // file-top comment on TS2589), so `args` infers as the loose
+        // ShapeOutput<ZodRawShapeCompat> instead of the Zod schema above.
+        // Runtime shape is enforced by the schema; this re-asserts the typed
+        // contract at the consumer boundary. Task 404.
         const result = await memoryTypedEdgePass(args, dbSession, accountId);
         return {
             content: [{