@rubytech/create-siteoffice-code 0.1.256

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

@@ -0,0 +1,2522 @@
+import { initStderrTee } from "../../../../lib/mcp-stderr-tee/dist/index.js";
+initStderrTee("memory");
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { eagerTool } from "../../../../lib/mcp-eager/dist/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { int } from "neo4j-driver";
+import { memorySearch } from "./tools/memory-search.js";
+import { memoryWrite } from "./tools/memory-write.js";
+import { loadSchema } from "./lib/schema-loader.js";
+import { buildLiveSchemaSource, defaultSchemaCypherPath, } from "./lib/live-schema-source.js";
+import { memoryReindex } from "./tools/memory-reindex.js";
+import { memoryIngestExtract } from "./tools/memory-ingest-extract.js";
+import { memoryIngest } from "./tools/memory-ingest.js";
+import { CONVERSATION_SOURCES } from "./lib/conversation-normalisers/types.js";
+import { kdClassify } from "./tools/kd-classify.js";
+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 :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 { memoryUpdate } from "./tools/memory-update.js";
+import { memoryEdge } from "./tools/memory-edge.js";
+import { memoryUpdateByName } from "./tools/memory-update-by-name.js";
+import { memoryDelete } from "./tools/memory-delete.js";
+import { memoryFindCandidates } from "./tools/memory-find-candidates.js";
+import { memoryNodeExists, ALLOWED_LABELS as MEMORY_NODE_EXISTS_LABELS } from "./tools/memory-node-exists.js";
+import { memoryLookupByName } from "./tools/memory-lookup-by-name.js";
+import { memoryRestore } from "./tools/memory-restore.js";
+import { memoryEmptyTrash } from "./tools/memory-empty-trash.js";
+import { memoryListAttachments } from "./tools/memory-list-attachments.js";
+import { memoryReadAttachment } from "./tools/memory-read-attachment.js";
+import { memoryEditAttachment } from "./tools/memory-edit-attachment.js";
+import { memoryRenameAttachment } from "./tools/memory-rename-attachment.js";
+import { profileRead } from "./tools/profile-read.js";
+import { memoryBrainCaptureRecent } from "./tools/memory-brain-capture-recent.js";
+import { profileUpdate } from "./tools/profile-update.js";
+import { profileDelete } from "./tools/profile-delete.js";
+import { graphPruneDenylistAdd } from "./tools/graph-prune-denylist-add.js";
+import { graphPruneDenylistList } from "./tools/graph-prune-denylist-list.js";
+import { graphPruneDenylistRemove } from "./tools/graph-prune-denylist-remove.js";
+import { conversationMemoryExpunge } from "./tools/conversation-memory-expunge.js";
+import { conversationArchiveDeriveInsights, PROPOSAL_KINDS, } from "./tools/conversation-archive-derive-insights.js";
+import { conversationArchiveListChunks } from "./tools/conversation-archive-list-chunks.js";
+import { conversationArchiveEnrichRejection } from "./tools/conversation-archive-enrich-rejection.js";
+import { fetchImageAsContent } from "./tools/image-fetch.js";
+import { memoryTypedEdgePass } from "./tools/memory-typed-edge-pass.js";
+import { memoryReportWrite } from "./tools/memory-report-write.js";
+import { memoryReportReadLatest } from "./tools/memory-report-read-latest.js";
+import { memoryReportList } from "./tools/memory-report-list.js";
+import { memoryDreamRun } from "./tools/memory-dream-run.js";
+import { memoryReviewQueue } from "./tools/memory-review-queue.js";
+import { memoryCompiledTruthHistory } from "./tools/memory-compiled-truth-history.js";
+import { getSession, closeDriver } from "./lib/neo4j.js";
+import { embed } from "./lib/embeddings.js";
+import { notTrashed } from "../../../../lib/graph-trash/dist/index.js";
+const server = new McpServer({
+    name: "maxy-memory",
+    version: "0.1.0",
+});
+const readOnly = process.env.READ_ONLY === "true";
+// Plugin-system boot tolerance — see Task 202.
+// Module-init must never throw; plugin-system spawn enumerates tools/list
+// before ACCOUNT_ID is set. Per-call refusal preserves account isolation.
+const accountId = process.env.ACCOUNT_ID ?? null;
+// Task 476/487 — extended boot signal: sessionId, agentSlug (provenance),
+// and agentScope (read-scope) land here so a stale spawn-env contract is
+// visible at the first byte of stderr. Regression shapes: `sessionId ===
+// accountId`; `agentSlug` empty on a specialist spawn (provenance lost);
+// `agentScope` non-empty on the admin operator spawn (search wrongly scoped).
+process.stderr.write(`[memory] boot accountId=${accountId ?? "null"} sessionId=${process.env.SESSION_ID || "-"} agentSlug=${process.env.AGENT_SLUG || "-"} agentScope=${process.env.AGENT_SLUG_SCOPE || "-"}\n`);
+function refuseNoAccount(toolName) {
+    process.stderr.write(`[memory] tool=${toolName} refuse reason=no-account-context\n`);
+    return {
+        content: [
+            {
+                type: "text",
+                text: `${toolName} cannot execute: this MCP instance was launched without ACCOUNT_ID (plugin-system metadata-only mode). Per-account graph access requires ACCOUNT_ID at spawn.`,
+            },
+        ],
+        isError: true,
+    };
+}
+// Load the markdown schema sidecar once at startup. Every memory-write call
+// reads its required-property and synonym maps. If loading fails we throw —
+// a memory server running with a broken schema is worse than one that fails
+// to start loudly.
+const schema = loadSchema();
+// Live label source. The memory MCP runs as a separate stdio
+// process from graph-mcp, so it owns its own SchemaCache instance backed by
+// the existing Neo4j driver. The cache refreshes every 60s and tap-fires
+// drift detection from its emit hook. Boot does NOT block on the first
+// refresh — `defaultDeclaredOnly` is sufficient until live joins, since
+// declared labels cover the bootstrap labels (LocalBusiness etc.).
+const schemaCypherPath = defaultSchemaCypherPath();
+const liveSchemaRuntime = buildLiveSchemaSource({
+    schemaCypherPath,
+    markdownLabels: schema.markdownLabels.keys(),
+    fetcher: {
+        async labels() {
+            const session = getSession();
+            try {
+                const result = await session.run("CALL db.labels() YIELD label RETURN label");
+                return result.records
+                    .map((r) => r.get("label"))
+                    .filter((v) => typeof v === "string");
+            }
+            finally {
+                await session.close();
+            }
+        },
+        async relationshipTypes() {
+            const session = getSession();
+            try {
+                const result = await session.run("CALL db.relationshipTypes() YIELD relationshipType RETURN relationshipType");
+                return result.records
+                    .map((r) => r.get("relationshipType"))
+                    .filter((v) => typeof v === "string");
+            }
+            finally {
+                await session.close();
+            }
+        },
+    },
+});
+// Boot drift fires once the first refresh resolves. We do not await — the
+// validator handles boot races by accepting declared labels (which include
+// the bootstrap set) until live joins. Drift logs land in server.log as
+// soon as the snapshot lands, with no impact on serving requests.
+liveSchemaRuntime.ready.then(() => {
+    process.stderr.write(`[schema-validator] using-cache cacheAgeMs=0 ready=${liveSchemaRuntime.source.liveReady()}\n`);
+});
+const validator = {
+    schema,
+    liveSource: liveSchemaRuntime.source,
+};
+const userId = process.env.USER_ID; // Optional — present for admin sessions with users.json auth
+// Scope filtering: comma-separated list of allowed scopes (e.g. "public,shared").
+// When set, memory-search only returns nodes whose scope is in this list.
+// When absent (admin), no scope filtering is applied.
+const allowedScopes = process.env.ALLOWED_SCOPES
+    ? process.env.ALLOWED_SCOPES.split(",").map((s) => s.trim()).filter(Boolean)
+    : undefined;
+// Task 485 — per-visitor slice ringfence. Stamped by pty-spawner on
+// gated public-agent spawns. When present, every memory-search WHERE
+// composes `(n.sliceToken = $sliceToken OR n.scope IN $allowedScopes)`
+// so the agent sees its visitor's user-scoped nodes alongside public-scope
+// rows. When absent (admin path + open-mode public), behaviour is
+// unchanged.
+const accessSliceToken = typeof process.env.ACCESS_SLICE_TOKEN === "string" && process.env.ACCESS_SLICE_TOKEN.length > 0
+    ? process.env.ACCESS_SLICE_TOKEN
+    : undefined;
+// Per-handler session resolution. Module-load env capture was
+// wrong: when the admin agent didn't set SESSION_ID on MCP spawn, `sessionId`
+// was undefined for the entire process lifetime — every subsequent
+// `createdBySession` write was empty. Read per-handler so the env value
+// (now set in claude-agent.ts:3107 baseEnv) is observed at call time, and
+// allow per-call override via tool argument when an agent has better info.
+function resolveSessionId(override) {
+    if (override && override.trim())
+        return override.trim();
+    const fromEnv = process.env.SESSION_ID;
+    return fromEnv && fromEnv.trim() ? fromEnv.trim() : undefined;
+}
+// Provenance stamp: AGENT_SLUG is the agent identity recorded as
+// `createdByAgent` on every write. The admin operator gets the 'admin'
+// sentinel (Task 487); specialists/public get their slug.
+const envAgentSlug = process.env.AGENT_SLUG || undefined;
+// Per-agent knowledge scoping (Task 487 split this off AGENT_SLUG): when set,
+// memory-search only returns nodes whose `agents` array contains this slug.
+// Specialists/public get their slug here (server-level enforcement); the admin
+// operator gets EMPTY so search stays wide-open. For admin, an optional tool
+// param can still scope a single query. Read-scope and provenance are now
+// independent — admin writes stamp 'admin' while admin reads stay unscoped.
+const envAgentScopeSlug = process.env.AGENT_SLUG_SCOPE || undefined;
+// Keyword subscriptions: comma-separated list of keywords for BM25-based reactive
+// knowledge inclusion. When set, memory-search runs a BM25 query per keyword and
+// unions results with directly-tagged nodes. Capped at 5 for Pi performance.
+const MAX_KEYWORD_SUBSCRIPTIONS = 5;
+const envKeywordSubscriptions = process.env.KNOWLEDGE_KEYWORDS
+    ? process.env.KNOWLEDGE_KEYWORDS.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean).slice(0, MAX_KEYWORD_SUBSCRIPTIONS)
+    : undefined;
+// Output character budget for memory-search results. Claude Code's tool result token
+// limit is roughly 100K chars; 80K leaves headroom for MCP framing and avoids the
+// dump-to-file cascade that forces multi-step Bash parsing.
+const OUTPUT_CHAR_BUDGET = 80_000;
+/** Format a single search result. When includeRelated is false, related nodes are omitted. */
+function formatResult(r, includeRelated) {
+    let text = `[${r.labels.join(", ")}] (id: ${r.nodeId}) (score: ${r.score.toFixed(3)})\n`;
+    for (const [k, v] of Object.entries(r.properties)) {
+        text += `  ${k}: ${String(v)}\n`;
+    }
+    if (includeRelated && r.related.length > 0) {
+        text += "  Related:\n";
+        for (const rel of r.related) {
+            const arrow = rel.direction === "outgoing" ? `--[${rel.relationship}]-->` : `<--[${rel.relationship}]--`;
+            text += `    ${arrow} [${rel.labels.join(", ")}]`;
+            const relProps = Object.entries(rel.properties)
+                .filter(([k]) => k !== "embedding" && k !== "accountId")
+                .map(([k, v]) => `${k}: ${String(v)}`)
+                .join(", ");
+            if (relProps)
+                text += ` {${relProps}}`;
+            text += "\n";
+        }
+    }
+    return text;
+}
+eagerTool(server, "memory-search", "Search the knowledge graph using semantic vector search with graph traversal. Returns relevant nodes and their relationships.", {
+    query: z.string().describe("Natural language search query"),
+    labels: z
+        .array(z.string())
+        .optional()
+        .describe("Filter by node labels (e.g. Question, Service, DefinedTerm, Review, Person)"),
+    limit: z
+        .number()
+        .optional()
+        .describe("Maximum number of results (default 10)"),
+    expandHops: z
+        .number()
+        .optional()
+        .describe("Graph traversal depth for related nodes (default 1). Use 0 for listing/inventory queries (node properties only, compact output). Use 1 for deep context queries (includes related nodes — can produce large output for nodes with many relationships)."),
+    keywords: z
+        .array(z.string())
+        .optional()
+        .describe("Filter KnowledgeDocument results to those containing these topic keywords"),
+    keywordMatch: z
+        .enum(["any", "all"])
+        .optional()
+        .describe("Keyword match mode: 'any' (default, OR — matches docs with any listed keyword) or 'all' (AND — must have every keyword)"),
+    agentSlug: z
+        .string()
+        .optional()
+        .describe("Filter to nodes tagged for this agent slug (nodes where slug is in the agents array). For admin use — public agents use server-level env var."),
+    fields: z
+        .array(z.string())
+        .optional()
+        .describe("Narrow the response `properties` to these keys per result. Omit to return all properties (default). Empty array returns no properties (explicit 'none'). Unknown keys are silently skipped; nodes lacking a requested key omit it on that row. Use for known-shape lookups (slug → name) to avoid shipping bios, notes, source URLs on every turn. Ranking is unaffected — hybrid() sees the full text either way. See `references/graph-primitives.md` § Projecting fields."),
+    retrievalClass: z
+        .enum(["entity", "temporal", "event", "general", "none"])
+        .optional()
+        .describe("Hint that selects the per-class index mix (route-hint contract). Pass 'entity' for who/what-is-this lookups (vector-heavy, Person|Company|Concept filter), 'temporal' for when-did-this-happen (BM25-heavy over :Event with Timeline), 'event' for pure event listings, 'none' to skip graph lookup entirely (greetings/instructions). Omit or pass 'general' for the balanced default. Routing only takes effect when MAXY_GS_ROUTE is enabled; otherwise the value is recorded in the log line but does not change index selection."),
+}, async ({ query, labels, limit, expandHops, keywords, keywordMatch, agentSlug: toolAgentSlug, fields, retrievalClass }) => {
+    if (!accountId)
+        return refuseNoAccount("memory-search");
+    // AGENT_SLUG_SCOPE takes precedence over the tool param (security: public
+    // agent server-level enforcement). Empty for the admin operator, so admin
+    // falls through to the optional tool param (default: unscoped).
+    const effectiveAgentSlug = envAgentScopeSlug ?? toolAgentSlug;
+    try {
+        const results = await memorySearch({
+            query,
+            labels,
+            accountId,
+            limit,
+            expandHops,
+            allowedScopes,
+            sliceToken: accessSliceToken,
+            keywords,
+            keywordMatch,
+            agentSlug: effectiveAgentSlug,
+            keywordSubscriptions: envKeywordSubscriptions,
+            fields,
+            retrievalClass,
+        });
+        // Task 485 — per-call slice/public/user breakdown so the
+        // `[memory-search] sliceFilter=…|none publicCount=… userCount=…` grep
+        // proves the gated filter fired on the right turn. Inspects results
+        // after hybrid() applied the WHERE, so the counts reflect what the
+        // agent actually saw, not the unscoped corpus.
+        let publicCount = 0;
+        let userCount = 0;
+        for (const r of results) {
+            const scope = r.properties.scope;
+            const sliceTokenRow = r.properties.sliceToken;
+            if (scope === "public")
+                publicCount += 1;
+            if (typeof sliceTokenRow === "string" && sliceTokenRow.length > 0)
+                userCount += 1;
+        }
+        process.stderr.write(`[memory-search] sliceFilter=${accessSliceToken ? accessSliceToken.slice(0, 8) : "none"} ` +
+            `resultCount=${results.length} publicCount=${publicCount} userCount=${userCount}\n`);
+        if (results.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No results found for this query.",
+                    },
+                ],
+            };
+        }
+        const formatted = results.map((r) => formatResult(r, true));
+        const separator = "\n---\n";
+        let output = formatted.join(separator);
+        let droppedRelated = 0;
+        let droppedResults = 0;
+        if (output.length > OUTPUT_CHAR_BUDGET) {
+            const originalChars = output.length;
+            // Pass 1: strip related nodes from lowest-scored results first.
+            // Results are already sorted by score descending, so we iterate
+            // from the tail (lowest score) toward the head.
+            for (let i = formatted.length - 1; i >= 0 && output.length > OUTPUT_CHAR_BUDGET; i--) {
+                if (results[i].related.length > 0) {
+                    droppedRelated += results[i].related.length;
+                    formatted[i] = formatResult(results[i], false);
+                    output = formatted.join(separator);
+                }
+            }
+            // Pass 2: if still over budget, drop entire results from the tail.
+            while (formatted.length > 0 && output.length > OUTPUT_CHAR_BUDGET) {
+                formatted.pop();
+                droppedResults++;
+                output = formatted.join(separator);
+            }
+            const notice = `\n\n[Truncated: ${droppedRelated} related nodes removed` +
+                (droppedResults > 0 ? `, ${droppedResults} results omitted` : "") +
+                `. Use expandHops: 0 for compact listing, or reduce limit.]`;
+            output += notice;
+            process.stderr.write(`[memory-search] [${accountId}] output truncated: ${originalChars} → ${output.length}, ` +
+                `${droppedRelated} related nodes dropped, ${droppedResults} results dropped\n`);
+        }
+        return {
+            content: [{ type: "text", text: output }],
+        };
+    }
+    catch (err) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Search failed: ${err instanceof Error ? err.message : String(err)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+eagerTool(server, "memory-lookup-by-name", "Deterministic by-name entity lookup. Returns every node whose `name` matches " +
+    "the given name exactly (case-insensitive), bypassing the memory-search ranking " +
+    "stack — a name match is a predicate, not a similarity score, so there is no " +
+    "result cut to fall below. Use this when memory-search returns no result for a " +
+    "named entity you believe exists, or when the operator asks for 'the X node' by " +
+    "name. Optionally constrain by `labels`. Scoped to your account, allowed scopes, " +
+    "slice, and agent the same way memory-search is, and excludes trashed nodes. " +
+    "Returns an explicit empty list when nothing matches (not an error). For ranked " +
+    "fuzzy/semantic discovery use memory-search instead.", {
+    name: z.string().describe("Exact entity name to match (case-insensitive). e.g. \"Rubytech LLC\"."),
+    labels: z
+        .array(z.string())
+        .optional()
+        .describe("Optional label filter — return only nodes carrying any of these labels (e.g. [\"Organization\"]). Omit to match on name alone across all labels."),
+    limit: z
+        .number()
+        .optional()
+        .describe("Maximum number of matching nodes to return (default 25)."),
+}, async ({ name, labels, limit }) => {
+    if (!accountId)
+        return refuseNoAccount("memory-lookup-by-name");
+    const effectiveAgentSlug = envAgentScopeSlug;
+    try {
+        const hits = await memoryLookupByName({
+            name,
+            accountId,
+            labels,
+            allowedScopes,
+            sliceToken: accessSliceToken,
+            agentSlug: effectiveAgentSlug,
+            limit,
+        });
+        process.stderr.write(`[memory-lookup-by-name] name=${JSON.stringify(name)} ` +
+            `labels=${labels && labels.length > 0 ? labels.join("|") : "any"} ` +
+            `resultCount=${hits.length} ` +
+            `scope=${accessSliceToken ? accessSliceToken.slice(0, 8) : allowedScopes ? allowedScopes.join("|") : "admin"}\n`);
+        if (hits.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No node found with name=${JSON.stringify(name)}${labels && labels.length > 0 ? ` and labels=[${labels.join(", ")}]` : ""}.`,
+                    },
+                ],
+            };
+        }
+        const formatted = hits.map((h) => {
+            let text = `[${h.labels.join(", ")}] (id: ${h.nodeId})\n`;
+            for (const [k, v] of Object.entries(h.properties)) {
+                text += `  ${k}: ${String(v)}\n`;
+            }
+            return text;
+        });
+        return { content: [{ type: "text", text: formatted.join("\n---\n") }] };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `memory-lookup-by-name failed: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+});
+// ---------------------------------------------------------------------------
+// conversation-archive Phase 2 — chunk page reader (Task 433).
+// Returns one page of :Section chunk bodies for the named :ConversationArchive
+// so the conversation-archive-enrich skill can drive the dispatched
+// specialist to read each chunk and emit claims in-turn. Read-only.
+// ---------------------------------------------------------------------------
+server.tool("conversation-archive-list-chunks", "Page through the :Section chunks of one named :ConversationArchive and return each chunk's elementId, ordered index, summary, and full body. The conversation-archive-enrich skill calls this per page, then prompts the dispatched specialist to read each chunk's body in-turn and emit claims; the skill hands those claims back to `conversation-archive-derive-insights` for per-kind cypher emission. Read-only.", {
+    archiveElementId: z
+        .string()
+        .describe("elementId of the :ConversationArchive parent (Task 397 — keyed on conversationIdentity) the operator named (required)."),
+    chunkOffset: z
+        .number()
+        .int()
+        .nonnegative()
+        .optional()
+        .describe("Zero-based chunk offset. Default 0. Advance by chunkLimit per page."),
+    chunkLimit: z
+        .number()
+        .int()
+        .positive()
+        .max(20)
+        .optional()
+        .describe("Chunks per page (1..20). Default 5."),
+}, async ({ archiveElementId, chunkOffset, chunkLimit }) => {
+    if (!accountId)
+        return refuseNoAccount("conversation-archive-list-chunks");
+    try {
+        const result = await conversationArchiveListChunks({
+            accountId,
+            archiveElementId,
+            chunkOffset,
+            chunkLimit,
+        });
+        const header = `archiveElementId=${result.archiveElementId} title=${JSON.stringify(result.archiveTitle ?? "")} totalChunks=${result.totalChunks} walked=${result.walkedFrom}..${result.walkedTo} chunks=${result.chunks.length} chunksRemaining=${result.chunksRemaining}`;
+        const chunkBlocks = result.chunks
+            .map((c) => [
+            `Chunk ${c.index + 1}/${result.totalChunks}:`,
+            `  elementId=${c.elementId}`,
+            `  summary=${JSON.stringify(c.summary)}`,
+            `  body=${JSON.stringify(c.body)}`,
+        ].join("\n"))
+            .join("\n\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result.chunks.length === 0
+                        ? `${header}\n(no chunks at this offset)`
+                        : `${header}\n\n${chunkBlocks}`,
+                },
+            ],
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: "text", text: msg }],
+            isError: true,
+        };
+    }
+});
+process.stderr.write("[memory-mcp] registered tool=conversation-archive-list-chunks\n");
+// ---------------------------------------------------------------------------
+// conversation-archive Phase 2: per-chunk claim → cypher proposal emitter.
+// Task 433: accepts the agent-produced `claims` array for one chunk (read
+// from `conversation-archive-list-chunks`) and returns operator-facing
+// proposals carrying the per-kind mergeCypher. Rejection sidecar filter is
+// applied here. The tool itself NEVER writes; idempotency lives on the
+// MERGE-key (chunkElementId, kind, contentHash) baked into each mergeCypher.
+// ---------------------------------------------------------------------------
+const claimSchema = z.object({
+    kind: z.enum([...PROPOSAL_KINDS]).describe("One of: mention, task, preference, observed-relationship."),
+    evidenceSnippet: z
+        .string()
+        .describe("Near-verbatim quote from the chunk body (≤80 chars enforced server-side)."),
+    subject: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("Display name of the primary entity. Required for mention + observed-relationship."),
+    object: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("Display name of the related entity. Required for observed-relationship only."),
+    payload: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe("Kind-specific structured fields (taskTitle/taskDueHint for task; preferenceCategory/preferenceKey/preferenceValue for preference; relationshipType for observed-relationship)."),
+});
+server.tool("conversation-archive-derive-insights", "Convert one chunk's agent-produced claims into operator-facing claim proposals (mention, task, preference, observed-relationship). The conversation-archive-enrich skill reads chunk bodies via `conversation-archive-list-chunks`, drives the dispatched specialist to emit claims in-turn, and passes them here for per-kind cypher emission. Applies the durable rejection sidecar so already-triaged claims do not re-surface. Read-only: the per-row operator gate runs in the skill, this tool never writes.", {
+    archiveElementId: z
+        .string()
+        .describe("elementId of the :ConversationArchive parent (Task 397 — keyed on conversationIdentity) the operator named (required)."),
+    chunkElementId: z
+        .string()
+        .describe("elementId of the single :Section chunk the agent just read (required)."),
+    claims: z
+        .array(claimSchema)
+        .describe("Claims the dispatched specialist emitted in-turn from the chunk body. Zero is valid — pass [] to record an empty-chunk pass."),
+    inlineRewrite: z.boolean().optional().describe("When true, count mention-claim subjects in this chunk and return those reaching inlineRewriteThreshold in inlineRewriteSignals. The calling skill accumulates signals across chunks; when an entity's cumulative count hits threshold, resolve it via memory-search and dispatch the compiled-truth-rewriter specialist."),
+    inlineRewriteThreshold: z.number().int().min(1).optional().describe("Minimum mention-claim count for a subject to appear in inlineRewriteSignals. Default: 2."),
+}, async ({ archiveElementId, chunkElementId, claims, inlineRewrite, inlineRewriteThreshold }) => {
+    if (!accountId)
+        return refuseNoAccount("conversation-archive-derive-insights");
+    try {
+        const result = await conversationArchiveDeriveInsights({
+            accountId,
+            archiveElementId,
+            chunkElementId,
+            claims: claims,
+            sessionId: resolveSessionId(),
+            inlineRewrite,
+            inlineRewriteThreshold,
+        });
+        const proposalLines = result.proposals
+            .map((p, i) => {
+            const disambig = p.disambiguation && p.disambiguation.needsResolution.length > 0
+                ? ` resolve:${p.disambiguation.needsResolution.map((r) => `${r.role}="${r.displayName}"`).join(",")}`
+                : "";
+            return [
+                `Proposal ${i + 1}/${result.proposals.length}:`,
+                `  chunkElementId=${p.chunkElementId}`,
+                `  kind=${p.kind}`,
+                `  contentHash=${p.contentHash}`,
+                `  evidence="${p.evidenceSnippet}"`,
+                `  proposedAction=${p.proposedAction}${disambig}`,
+                `  mergeCypher=${p.mergeCypher.replace(/\n/g, " ")}`,
+                `  mergeParams=${JSON.stringify(p.mergeParams)}`,
+            ].join("\n");
+        })
+            .join("\n\n");
+        const signalsSuffix = result.inlineRewriteSignals && result.inlineRewriteSignals.length > 0
+            ? ` inlineRewriteSignals=${JSON.stringify(result.inlineRewriteSignals)}`
+            : "";
+        const header = `archiveElementId=${result.archiveElementId} chunkElementId=${result.chunkElementId} proposals=${result.proposals.length} rejectionsFiltered=${result.rejectionsFiltered} invalidClaims=${result.invalidClaims}${signalsSuffix}`;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result.proposals.length === 0
+                        ? `${header}\n(no proposals from this chunk's claims)`
+                        : `${header}\n\n${proposalLines}`,
+                },
+            ],
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: "text", text: msg }],
+            isError: true,
+        };
+    }
+});
+process.stderr.write("[memory-mcp] registered tool=conversation-archive-derive-insights\n");
+// ---------------------------------------------------------------------------
+// durable rejection memory for conversation-archive-enrich.
+// Writes to a sidecar JSONL alongside the account's state directory; the
+// filter step in conversation-archive-derive-insights reads the same file.
+// Modes:
+//   record — append rejection line (idempotent on duplicate keys).
+//   undo   — drop matching line via atomic-rename (called after a `wire`
+//            so a later wire of a once-rejected key cleans up its rejection).
+// ---------------------------------------------------------------------------
+server.tool("conversation-archive-enrich-rejection", "Record or undo a per-row rejection from conversation-archive-enrich. Writes a sidecar JSONL keyed on (chunkElementId, kind, contentHash). Call with mode='record' on operator `reject`; call with mode='undo' after a successful `wire` so a later wire of a once-rejected key clears its rejection. Idempotent: duplicate records are no-ops.", {
+    archiveElementId: z
+        .string()
+        .describe("elementId of the conversation-document parent (carried on each line for diagnostics)."),
+    chunkElementId: z
+        .string()
+        .describe("elementId of the :Section chunk the rejection applies to."),
+    kind: z
+        .string()
+        .describe("Proposal kind — one of mention|task|preference|observed-relationship."),
+    contentHash: z
+        .string()
+        .describe("The proposal's contentHash (sha256 over kind + payload)."),
+    mode: z
+        .enum(["record", "undo"])
+        .describe("record = append rejection; undo = remove rejection (called after `wire`)."),
+}, async ({ archiveElementId, chunkElementId, kind, contentHash, mode }) => {
+    if (!accountId)
+        return refuseNoAccount("conversation-archive-enrich-rejection");
+    try {
+        const result = await conversationArchiveEnrichRejection({
+            accountId,
+            archiveElementId,
+            chunkElementId,
+            kind,
+            contentHash,
+            mode,
+            sessionId: resolveSessionId(),
+        });
+        const summary = `mode=${result.mode} beforeCount=${result.beforeCount} afterCount=${result.afterCount} path=${result.path}`;
+        return {
+            content: [{ type: "text", text: summary }],
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[conversation-archive-enrich] rejection-tool-fail mode=${mode} chunk=${chunkElementId} reason="${msg}"\n`);
+        return {
+            content: [{ type: "text", text: msg }],
+            isError: true,
+        };
+    }
+});
+process.stderr.write("[memory-mcp] registered tool=conversation-archive-enrich-rejection\n");
+// ---------------------------------------------------------------------------
+// :Report read surface (Task 332). Both tools are read-only and available
+// to admin agents without the !readOnly gate. Routing for "latest X" /
+// "show me X report" intents lives in the admin IDENTITY.md clause and in
+// these tools' descriptions.
+// ---------------------------------------------------------------------------
+eagerTool(server, "memory-report-read-latest", "Return the most recent :Report node tagged with the given keyword. Reports are the durable output of admin workflows (daily briefing, dream cycle, ad-hoc analyses) — keyword-routed so 'latest briefing' or 'last night's dream cycle' resolve deterministically. Default limit=1 returns just the freshest match; raise it to scan a window. Prefer this over memory-search when the operator says 'latest', 'last', 'most recent', or 'show me the X report'.", {
+    keyword: z
+        .string()
+        .min(1)
+        .describe("Keyword to match against the report's keywords array (e.g. 'daily-briefing', 'dream-cycle'). Any-match — a report with this keyword in its array qualifies."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(20)
+        .optional()
+        .describe("Maximum number of reports to return, newest first. Default 1."),
+}, async ({ keyword, limit }) => {
+    if (!accountId)
+        return refuseNoAccount("memory-report-read-latest");
+    try {
+        const result = await memoryReportReadLatest({ accountId, keyword, limit });
+        if (result.results.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No reports found tagged with keyword '${keyword}'.`,
+                    },
+                ],
+            };
+        }
+        const body = result.results
+            .map((r) => {
+            const wf = r.sourceWorkflow ? ` (workflow=${r.sourceWorkflow})` : "";
+            return `# ${r.title}${wf}\nreportId: ${r.reportId}\noccurredAt: ${r.occurredAt}\nkeywords: ${r.keywords.join(", ")}\n\n${r.body}`;
+        })
+            .join("\n\n---\n\n");
+        return { content: [{ type: "text", text: body }] };
+    }
+    catch (err) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `memory-report-read-latest failed: ${err instanceof Error ? err.message : String(err)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+eagerTool(server, "memory-report-list", "List :Report nodes, newest first, with optional keyword and sourceWorkflow filters. Returns metadata only (title, keywords, sourceWorkflow, occurredAt, body length) — no body — so the agent can scan the catalogue without paying for full bodies. Use memory-report-read-latest to fetch the body of the single most recent match for a keyword.", {
+    keyword: z
+        .string()
+        .optional()
+        .describe("Optional keyword filter (any-match against the report's keywords array)."),
+    sourceWorkflow: z
+        .string()
+        .optional()
+        .describe("Optional exact-match filter on the originating workflow (e.g. 'daily-briefing', 'dream-cycle')."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe("Page size, newest first. Default 20, max 100."),
+    offset: z
+        .number()
+        .int()
+        .min(0)
+        .optional()
+        .describe("Zero-based offset for pagination. Default 0."),
+}, async ({ keyword, sourceWorkflow, limit, offset }) => {
+    if (!accountId)
+        return refuseNoAccount("memory-report-list");
+    try {
+        const result = await memoryReportList({
+            accountId,
+            keyword,
+            sourceWorkflow,
+            limit,
+            offset,
+        });
+        if (result.results.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No reports found${keyword ? ` for keyword '${keyword}'` : ""}${sourceWorkflow ? ` (workflow='${sourceWorkflow}')` : ""}.`,
+                    },
+                ],
+            };
+        }
+        const header = `Showing ${result.results.length} of ${result.total} reports.`;
+        const rows = result.results
+            .map((r) => {
+            const wf = r.sourceWorkflow ? ` workflow=${r.sourceWorkflow}` : "";
+            return `- ${r.occurredAt}  ${r.title}  [${r.keywords.join(",")}]${wf}  body=${r.bodyChars}c  id=${r.reportId.slice(0, 8)}  elementId=${r.nodeId}`;
+        })
+            .join("\n");
+        return {
+            content: [{ type: "text", text: `${header}\n${rows}` }],
+        };
+    }
+    catch (err) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `memory-report-list failed: ${err instanceof Error ? err.message : String(err)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+process.stderr.write("[memory-mcp] registered tool=memory-report-read-latest\n");
+process.stderr.write("[memory-mcp] registered tool=memory-report-list\n");
+eagerTool(server, "memory-compiled-truth-history", "Return the audit history of `compiledTruth` values for one entity (:Person | :Organization | :Concept), newest first, capped at 20 revisions. Each row carries the truth text, when it was written, and whether the rewriter or an operator authored it. Use when the operator asks 'how has my understanding of X changed over time?' or 'when did the agent introduce this claim about X?' — pass the entity's elementId and present the diff between adjacent revisions in chat.", {
+    nodeId: z
+        .string()
+        .describe("elementId of the :Person | :Organization | :Concept whose revision history is being read."),
+}, async ({ nodeId }) => {
+    if (!accountId)
+        return refuseNoAccount("memory-compiled-truth-history");
+    try {
+        const result = await memoryCompiledTruthHistory({ accountId, nodeId });
+        if (result.revisions.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No compiled-truth revisions found for nodeId=${nodeId.slice(0, 12)}.`,
+                    },
+                ],
+            };
+        }
+        const header = `Showing ${result.revisions.length} revision(s) (newest first) for nodeId=${nodeId.slice(0, 12)}.`;
+        const rows = result.revisions
+            .map((r, i) => `## #${i + 1} ${r.writtenAt} source=${r.source} revisionId=${r.revisionId.slice(0, 8)}\n${r.truth}`)
+            .join("\n\n");
+        return { content: [{ type: "text", text: `${header}\n\n${rows}` }] };
+    }
+    catch (err) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `memory-compiled-truth-history failed: ${err instanceof Error ? err.message : String(err)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+process.stderr.write("[memory-mcp] registered tool=memory-compiled-truth-history\n");
+if (!readOnly) {
+    eagerTool(server, "memory-write", "Create a new node in the knowledge graph with automatic embedding computation. Every node must be created with at least one relationship — call memory-search first to find target elementIds. Writes targeting :Person, :UserProfile, :AdminUser, :Organization, :LocalBusiness, :CloudflareTunnel, or :CloudflareHostname additionally require an inbound :PRODUCED edge from :Task, :Conversation, or :Message. For autonomous workflows that own a :Task lifecycle, pass the Task's elementId as `producedByTaskId`. For direct asks during a conversation, omit `producedByTaskId` — the platform auto-injects the edge from the active conversation.", {
+        labels: z
+            .array(z.string())
+            .describe("Node labels (e.g. ['Person'], ['Question'], ['DefinedTerm'])"),
+        properties: z
+            .record(z.string(), z.unknown())
+            .describe("Node properties as key-value pairs"),
+        scope: z
+            .string()
+            .describe("Visibility scope — required. Valid values: 'public', 'shared', 'admin', or 'user:{identifier}'."),
+        relationships: z
+            .array(z.object({
+            type: z.string().describe("Relationship type (e.g. HAS_PRICING, OFFERS)"),
+            direction: z.enum(["outgoing", "incoming"]),
+            targetNodeId: z.string().describe("Element ID of the target node"),
+        }))
+            .min(1)
+            .describe("Relationships to create with existing nodes. At least one is required — a node without an adjacency is noise, not knowledge."),
+        producedByTaskId: z
+            .string()
+            .optional()
+            .describe("Active Task elementId for autonomous-workflow writes. When set, an inbound :PRODUCED edge from this Task is composed into relationships before the write. Task must share the same accountId; mismatch is rejected. Omit for direct conversation asks — the platform composes the edge from the active conversation instead."),
+    }, async ({ labels, properties, scope, relationships, producedByTaskId }) => {
+        if (!accountId)
+            return refuseNoAccount("memory-write");
+        try {
+            const result = await memoryWrite({
+                labels,
+                properties: properties,
+                accountId,
+                scope,
+                relationships,
+                createdBy: {
+                    agent: envAgentSlug,
+                    session: resolveSessionId(),
+                    tool: "memory-write",
+                },
+                validator,
+                producedByTaskId,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Node created: [${result.labels.join(", ")}] (ID: ${result.nodeId})`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Write failed: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    eagerTool(server, "memory-report-write", "Persist a workflow's output as a durable :Report node. Reports are append-only, keyword-routed, and embedded for hybrid search. Use at the end of any operator-initiated workflow whose output the operator will want to recall later — daily briefing, dream cycle, ad-hoc analyses. Idempotent on (title, occurredAt-within-same-minute): a second call with the same title in the same minute returns the existing report instead of duplicating. The platform auto-parents the report to the active conversation (or to the account's :AdminUser when no conversation context exists).", {
+        title: z
+            .string()
+            .min(1)
+            .describe("Short report title (e.g. 'Daily briefing 2026-05-25', 'Dream cycle 2026-05-25 14:30'). Used for idempotency together with occurredAt — same title in the same minute deduplicates."),
+        body: z
+            .string()
+            .max(10_000)
+            .describe("Report body in markdown. Maximum 10,000 characters; trim or summarise above the cap."),
+        keywords: z
+            .array(z.string().min(1))
+            .min(1)
+            .describe("Keyword tags used by memory-report-read-latest routing. Always include the workflow slug (e.g. 'daily-briefing', 'dream-cycle') plus the date in 'YYYY-MM-DD' form. Add topic keywords when the report focuses on one subject."),
+        sourceWorkflow: z
+            .string()
+            .optional()
+            .describe("Originating workflow slug for indexed lookup (e.g. 'daily-briefing', 'dream-cycle'). Recommended when the report comes from a named skill or scheduled workflow."),
+        occurredAt: z
+            .string()
+            .optional()
+            .describe("ISO 8601 timestamp the report describes. Defaults to now(). Override only when persisting a backdated report."),
+    }, async ({ title, body, keywords, sourceWorkflow, occurredAt }) => {
+        if (!accountId)
+            return refuseNoAccount("memory-report-write");
+        try {
+            const result = await memoryReportWrite({
+                accountId,
+                title,
+                body,
+                keywords,
+                sourceWorkflow,
+                occurredAt,
+                conversationNodeId: process.env.SESSION_NODE_ID,
+            });
+            const status = result.created
+                ? `Report created`
+                : `Report already existed (idempotent: ${result.idempotencyReason ?? "match"})`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `${status} — reportId: ${result.reportId} elementId: ${result.nodeId}`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `memory-report-write failed: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("memory-update-by-name", "Update an existing node addressed by (label, name, accountId) instead of elementId. Use this as a repair surface when memory-search cannot return an elementId for a node you know exists by name — typically an ingest-created :Organization the search route is failing to surface. Resolves the unique node matching the tuple, then delegates to memory-update (embedding refresh, write gates, compiled-truth refusal, and provenance stamping all carry over). Rejects loudly on zero matches (the row does not exist) and on two-or-more matches (ambiguous — the rejection lists candidate elementIds so you can pick one and call memory-update directly). Trashed nodes are excluded from the lookup. For one-off updates where you already have the elementId from a successful memory-search, prefer memory-update — this tool is the fallback when search hides the node.", {
+        label: z.string().describe("The single label to MATCH on (e.g. 'Organization', 'Person', 'Project'). Must be exactly the label carried by the target node — the tool does not iterate label variants."),
+        name: z.string().describe("The exact `name` property of the target node (case-sensitive). Forbidden-property rules still apply downstream — if the label rejects `name`, use memory-update with the correct identifier instead."),
+        properties: z
+            .record(z.string(), z.unknown())
+            .describe("Properties to set or overwrite. Same restrictions as memory-update — embedding/accountId/createdAt are silently stripped; compiled-truth fields are refused unless the caller is the compiled-truth-rewriter specialist."),
+    }, async ({ label, name, properties }) => {
+        if (!accountId)
+            return refuseNoAccount("memory-update-by-name");
+        try {
+            const result = await memoryUpdateByName({
+                label,
+                name,
+                accountId,
+                properties: properties,
+                createdBy: {
+                    agent: envAgentSlug,
+                    session: resolveSessionId(),
+                    tool: "memory-update-by-name",
+                },
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Node updated: [${result.labels.join(", ")}] (ID: ${result.nodeId})`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Update failed: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    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. To refresh `compiledTruth` / `compiledTruthPublic` on :Person / :Organization / :Concept / :Project / :LocalBusiness, dispatch the `compiled-truth-rewriter` specialist via the Task tool — admin sends the nodeId plus any `operatorHint` / `publicOperatorHint`; the specialist reads the node + 90-day timeline, computes the new summary, and writes it back via memory-update. Direct writes to compiled-truth properties via this tool are refused unless the caller is the compiled-truth-rewriter specialist (gated by MAXY_SPECIALIST env). When you only have the node's name (typically because memory-search couldn't return it), use memory-update-by-name instead.", {
+        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; only the compiled-truth-rewriter specialist may write them."),
+    }, async ({ nodeId, properties }) => {
+        if (!accountId)
+            return refuseNoAccount("memory-update");
+        try {
+            const result = await memoryUpdate({
+                nodeId,
+                properties: properties,
+                accountId,
+                createdBy: {
+                    agent: envAgentSlug,
+                    session: resolveSessionId(),
+                    tool: "memory-update",
+                },
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Node updated: [${result.labels.join(", ")}] (ID: ${result.nodeId})`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Update failed: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("memory-edge", "Create or delete a typed directed edge between two nodes that already exist in the knowledge graph. Both nodes must belong to the same account. Use action='create' to MERGE the edge (idempotent — returns {created:false} if it already exists) or action='delete' to remove it (returns {deleted:false} if already absent). relationshipType is uppercase-coerced; types starting with underscore are reserved and rejected. Properties are stamped on the edge on CREATE only.", {
+        action: z.enum(["create", "delete"]).describe("'create' MERGEs the edge (idempotent); 'delete' removes it (no-op if absent)."),
+        fromId: z.string().describe("elementId of the source node (from memory-search results)."),
+        toId: z.string().describe("elementId of the target node (from memory-search results)."),
+        relationshipType: z.string().describe("Relationship type label — e.g. RELATES_TO, MENTIONS, WORKED_WITH. Uppercase-coerced. Underscore-prefixed types (_SOFT_DELETE, etc.) are reserved and rejected."),
+        properties: z.record(z.string(), z.unknown()).optional().describe("Properties to set on the relationship on CREATE. Ignored on DELETE and on idempotent CREATE (MERGE-matched)."),
+    }, async ({ action, fromId, toId, relationshipType, properties }) => {
+        if (!accountId)
+            return refuseNoAccount("memory-edge");
+        try {
+            const result = await memoryEdge({
+                action,
+                fromId,
+                toId,
+                relationshipType,
+                properties,
+                accountId,
+            });
+            if ("error" in result) {
+                return {
+                    content: [{ type: "text", text: `memory-edge rejected: ${JSON.stringify(result)}` }],
+                    isError: true,
+                };
+            }
+            const detail = "created" in result
+                ? result.created
+                    ? "Edge created."
+                    : "Edge already exists (idempotent)."
+                : result.deleted
+                    ? "Edge deleted."
+                    : "Edge was not present (no-op).";
+            return { content: [{ type: "text", text: detail }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `memory-edge failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    eagerTool(server, "session-compact-status", "Check whether a session compaction summary exists in the graph. Returns the most recent summary title, date, and briefing text. Use this at session start to determine whether a prior session was compacted and its context should be restored.", {}, async () => {
+        if (!accountId)
+            return refuseNoAccount("session-compact-status");
+        const session = getSession();
+        try {
+            const result = await session.run(`MATCH (n:CreativeWork {accountId: $accountId})
+           WHERE n.title STARTS WITH 'Session Summary'
+           RETURN n.title AS title, n.createdAt AS createdAt, n.abstract AS abstract
+           ORDER BY n.createdAt DESC LIMIT 1`, { accountId });
+            if (result.records.length === 0) {
+                return { content: [{ type: "text", text: "No session summaries found." }] };
+            }
+            const r = result.records[0];
+            const text = `Title: ${r.get("title")}\nDate: ${r.get("createdAt")}\n\n${r.get("abstract")}`;
+            return { content: [{ type: "text", text }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `session-compact-status failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+        finally {
+            await session.close();
+        }
+    });
+    eagerTool(server, "session-compact", "Write a session summary to the knowledge graph. Call this when compacting context — provide the full briefing and the tool handles labelling, structure, and embedding.", {
+        content: z.string().describe("The session briefing — what was discussed, decisions made, work in progress, open questions, and anything learned about the user or their business"),
+    }, async ({ content }) => {
+        if (!accountId)
+            return refuseNoAccount("session-compact");
+        try {
+            // Write doctrine: session summaries link back to the
+            // Conversation they summarise, so an operator searching a session's
+            // graph sees the summary hanging off its source. Hard-require
+            // SESSION_ID — the previous revision fell back to "most recent
+            // admin Conversation" which would cross-attach a summary to an
+            // unrelated session hours later (reviewer flagged this as silent
+            // provenance corruption).
+            const sessionIdForCompact = resolveSessionId();
+            if (!sessionIdForCompact) {
+                throw new Error("session-compact requires SESSION_ID — the tool must be invoked inside an admin session so the summary can link back to its Conversation.");
+            }
+            const lookupSession = getSession();
+            let conversationElementId = null;
+            try {
+                const r = await lookupSession.run(`MATCH (c:Conversation {sessionKey: $sessionId, accountId: $accountId}) RETURN elementId(c) AS id LIMIT 1`, { sessionId: sessionIdForCompact, accountId });
+                if (r.records.length > 0) {
+                    conversationElementId = r.records[0].get("id");
+                }
+            }
+            finally {
+                await lookupSession.close();
+            }
+            if (!conversationElementId) {
+                throw new Error(`session-compact: no Conversation found with sessionKey=${sessionIdForCompact} in this account. Cannot link summary — refuse rather than create an orphan.`);
+            }
+            const title = `Session Summary ${new Date().toISOString().slice(0, 10)}`;
+            const result = await memoryWrite({
+                labels: ["CreativeWork"],
+                properties: { title, abstract: content },
+                accountId,
+                scope: "admin",
+                relationships: [
+                    {
+                        type: "SUMMARIZES",
+                        direction: "outgoing",
+                        targetNodeId: conversationElementId,
+                    },
+                ],
+                createdBy: {
+                    agent: envAgentSlug,
+                    session: sessionIdForCompact,
+                    tool: "session-compact",
+                },
+                validator,
+            });
+            return {
+                content: [{ type: "text", text: `Session summary saved (ID: ${result.nodeId})` }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `session-compact failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    eagerTool(server, "memory-reindex", "Rebuild vector embeddings for all nodes missing embeddings. Run after seeding or bulk updates.", {}, async () => {
+        if (!accountId)
+            return refuseNoAccount("memory-reindex");
+        try {
+            const result = await memoryReindex(accountId);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Reindex complete: ${result.nodesProcessed} processed, ${result.nodesSkipped} skipped, ${result.scopeBackfilled} scope backfilled.${result.errors.length > 0 ? `\nErrors: ${result.errors.join("; ")}` : ""}`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            console.error("[memory-reindex] failed:", err instanceof Error ? err.message : String(err));
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Reindex failed: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("memory-ingest-extract", "Extract text from an uploaded file and cache it server-side for memory-ingest. " +
+        "Supports PDF (via pdftotext), plain text, and markdown. " +
+        "Rejects CSV (structured data — use memory-write instead) and images (metadata-only). " +
+        "Returns file metadata + a short preview; the full text lives in the in-process cache keyed by attachmentId. " +
+        "The dispatched specialist reads the cached text and produces the typed-section JSON in-turn from the loaded ontology, then calls memory-ingest directly.", {
+        storagePath: z.string().describe("Absolute path to the stored file on disk"),
+        filename: z.string().describe("Original filename as uploaded"),
+        mimeType: z.string().describe("MIME type of the file"),
+        attachmentId: z.string().describe("UUID of the file attachment — used as cache key for memory-ingest"),
+    }, async ({ storagePath, filename, mimeType, attachmentId }) => {
+        if (!accountId)
+            return refuseNoAccount("memory-ingest-extract");
+        try {
+            const result = await memoryIngestExtract({ storagePath, filename, mimeType, attachmentId });
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify(result),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `memory-ingest-extract failed for "${filename}": ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("memory-ingest", "Write a classified document or conversation-archive session into the graph as typed nodes anchored to a subject. " +
+        "Two mutually-exclusive parent paths — exactly one MUST be set: " +
+        "(1) **Document path** — set `attachmentId` (requires a prior memory-ingest-extract call for the text cache). MERGEs under `:KnowledgeDocument` keyed on attachmentId. The typed-section JSON in `sections` is produced by the dispatched specialist in-turn from the loaded ontology. " +
+        "(2) **Conversation-archive path** — set `conversationIdentity` along with the conversation-document fields (`source`, `archiveSha256`, `archiveSourceFile`, `participantElementIds`, `lastIngestedMessageHash`, `lastIngestedMessageAt`, `sessionIndex`, optionally `archiveTitle` and `cleanupPriorChunks`). MERGEs under `:ConversationArchive` keyed on conversationIdentity. The specialist invokes this once per session prepared by `conversation-archive-ingest.sh`, advancing the cursor atomically with each session's chunks. `:Section.body` is server-sliced from the per-session turnText tempfile the bin wrote at `turnTextCachePath(conversationIdentity, archiveSha256, sessionIndex)` — the specialist emits offsets, never body text (server-sliced via per-session tempfile). " +
+        "Each section becomes either a typed graph node (Position, Service, Credential, etc.) anchored to the named " +
+        "subject via the natural ontology edge plus a (parent)-[:REFERENCES]->(typed) link, or — for " +
+        "UNMAPPED sections — a generic :Section node hanging off the parent via HAS_SECTION (legacy fallback). " +
+        "Document re-ingest replaces the document's typed and untyped children (same attachmentId). Conversation-archive re-ingest is delta-append: prior chunks are never touched unless `cleanupPriorChunks=true` is set (only legitimate on the FIRST session of a `--rebuild` run). " +
+        "Shared related entities (Organizations, Persons referenced by typed nodes) " +
+        "are MERGEd by identifying property and never deleted on re-ingest.", {
+        attachmentId: z.string().optional().describe("UUID of the file attachment — must match a prior memory-ingest-extract call. Document path only — mutually exclusive with conversationIdentity."),
+        conversationIdentity: z.string().optional().describe("sha256(accountId + ':' + sortedParticipantElementIds.join(',')) — produced by `conversation-archive-ingest.sh`. Conversation-archive path only — mutually exclusive with attachmentId."),
+        source: z.enum(CONVERSATION_SOURCES).optional().describe("Conversation source enum. Required on the conversation-archive path."),
+        archiveSha256: z.string().optional().describe("sha256 of the export bytes. Required on the conversation-archive path; stamped on every :Section chunk so cleanup-by-archiveSha256 is exact."),
+        archiveSourceFile: z.string().optional().describe("Basename of the source file (e.g. `_chat.txt`). Required on the conversation-archive path."),
+        participantElementIds: z.array(z.string()).optional().describe("Owner + operator-confirmed participants (elementIds). Required on the conversation-archive path. Owner is included first; :PARTICIPANT_IN edges land for every entry. Order is irrelevant for conversationIdentity, which is derived from a sorted set."),
+        lastIngestedMessageHash: z.string().optional().describe("sha256 of the last message in THIS session. Required on the conversation-archive path; written to :ConversationArchive.lastIngestedMessageHash atomically with this session's chunks for delta-append on the next ingest."),
+        lastIngestedMessageAt: z.string().optional().describe("ISO timestamp of the last message in THIS session. Required on the conversation-archive path; written to :ConversationArchive.lastIngestedMessageAt."),
+        archiveTitle: z.string().optional().describe("Stable archive title (`<source> · <owner> ↔ <others> · <YYYY-MM-DD>→<YYYY-MM-DD>`) computed by `conversation-archive-ingest.sh`. Written ON CREATE and COALESCE-on-MATCH so the UI label is stable across re-ingests. Conversation-archive path only."),
+        cleanupPriorChunks: z.boolean().optional().describe("When true, the writer deletes prior chunks for the matching archiveSha256 before MERGE. Set this ONLY on the FIRST session of a `--rebuild` run; subsequent sessions in the same run MUST set it false or the writer drops chunks the earlier sessions just wrote. Defaults to false."),
+        sessionIndex: z.number().int().min(1).optional().describe("Conversation-archive path: required. The per-session index emitted by `conversation-archive-ingest.sh` (1-based). The writer uses it together with `conversationIdentity` and `archiveSha256` to locate the per-session turnText tempfile written by the bin and slice :Section.body server-side from a non-LLM source (server-sliced via per-session tempfile). Ignored on the document path."),
+        documentSummary: z.string().describe("Classifier-produced summary (1-3 sentences) for the document path. On the conversation-archive path, pass the stable `archiveTitle` so the parent's summary matches the title."),
+        anchorNodeId: z.string().describe("Element ID of the anchor node. Document path: the operator-confirmed document subject (UserProfile/LocalBusiness/Person/Organization). Conversation-archive path: the owner :AdminUser elementId (or :Person for a third-party archive)."),
+        anchorLabel: z.string().describe("Primary label of the anchor node (e.g. 'UserProfile', 'LocalBusiness', 'AdminUser'). Used in the per-section MATCH for anchor-edge creation."),
+        sections: z.array(z.object({
+            kind: z.string().describe("Section kind from the closed enumeration (Position/Education/Chapter/Parties/.../Other), or a standalone-node kind like 'Project'."),
+            title: z.string(),
+            body: z.string().optional().describe("Omit on BOTH paths — the writer derives body server-side via cachedText.slice(sourceStart, sourceEnd). Document-path source: extractCache (server-side). Conversation-archive-path source: per-session tempfile written by the bin (server-sliced via per-session tempfile). Any value supplied here is logged and ignored."),
+            summary: z.string().describe("1-3 sentence summary of the section, ≤500 chars; stored as :Section.summary."),
+            sourceStart: z.number().int().nonnegative().describe("Whole-document char offset where the section begins (inclusive). Translated to whole-doc coords by the chunked-classify path."),
+            sourceEnd: z.number().int().nonnegative().describe("Whole-document char offset where the section ends (exclusive)."),
+            properties: z.record(z.string(), z.unknown()),
+            anchorEdge: z.object({
+                type: z.string(),
+                direction: z.enum(["from-anchor", "to-anchor"]),
+                properties: z.record(z.string(), z.unknown()).optional(),
+            }).nullable(),
+            related: z.array(z.object({
+                kind: z.string(),
+                properties: z.record(z.string(), z.unknown()),
+                edge: z.object({
+                    type: z.string(),
+                    direction: z.enum(["outgoing", "incoming"]),
+                    properties: z.record(z.string(), z.unknown()).optional(),
+                }),
+                merge: z.boolean().optional(),
+            })).optional(),
+            classifierReason: z.string().optional().describe("Required when kind === 'Other' — one-line description of what the section is about, stamped on :Section:Other.classifierReason for ontology-growth review."),
+        })).describe("Sections in reading order, produced in-turn by the dispatched specialist from the extract cache. The writer chains them via :NEXT in this order."),
+        documentEdges: z.array(z.object({
+            type: z.string(),
+            direction: z.enum(["outgoing", "incoming"]),
+            targetKind: z.string(),
+            targetProperties: z.record(z.string(), z.unknown()),
+            merge: z.boolean().optional(),
+        })).optional().describe("Document-level edges (e.g. PARTY edges off KnowledgeDocument for a contract). Currently emitted by the classifier when a Parties section is detected."),
+        orphanCandidates: z.array(z.object({
+            kind: z.string(),
+            label: z.string(),
+            reason: z.string(),
+        })).optional().describe("Orphan candidates from the classifier — nodes the classifier could not edge naturally. NOT written to the graph; the skill surfaces these to the operator loudly so they decide whether the orphan is intentional (rare, valid) or a classifier miss (bug)."),
+        scope: z.string().describe("Visibility scope for all created nodes — required. Valid values: 'public', 'shared', 'admin', or 'user:{identifier}'."),
+        sourceUrl: z.string().optional().describe("Original URL for web-sourced documents. Omit for file uploads."),
+        sourceType: z.string().optional().describe("Provenance: 'upload' or 'web'."),
+        documentKeywords: z.array(z.string()).optional().describe("Classifier-extracted topic keywords."),
+        userKeywords: z.array(z.string()).optional().describe("Keywords explicitly provided by the user. Merged additively with documentKeywords."),
+        sessionId: z.string().optional().describe("Session UUID for provenance stamping. Optional override; the server falls back to the SESSION_ID env var set by the admin agent at MCP spawn. The agent only needs to pass this when calling outside the normal admin-session context."),
+        inlineRewrite: z.boolean().optional().describe("When true, after writing all sections and edges, run the inline compiled-truth reconciliation gate. Counts MENTIONS/REFERENCES edges from this document (KnowledgeDocument + its sections) to existing entities that carry compiledTruth. Entities with >= inlineRewriteThreshold such edges (default 2) and compiledTruthUpdatedAt older than 7 days are returned in inlineRewriteCandidates. Dispatch the compiled-truth-rewriter specialist for each before the skill returns. Disabled by default."),
+        forceRewrite: z.boolean().optional().describe("When inlineRewrite is true, bypass the 7-day per-entity cooldown on compiledTruthUpdatedAt. All threshold-qualifying entities are returned as inlineRewriteCandidates regardless of when their truth was last rewritten."),
+        inlineRewriteThreshold: z.number().int().min(1).optional().describe("Minimum MENTIONS/REFERENCES edge count from this source to an entity for it to qualify as an inline-rewrite candidate. Default: 2."),
+    }, async ({ attachmentId, conversationIdentity, source, archiveSha256, archiveSourceFile, participantElementIds, lastIngestedMessageHash, lastIngestedMessageAt, archiveTitle, cleanupPriorChunks, sessionIndex, documentSummary, anchorNodeId, anchorLabel, sections, documentEdges, orphanCandidates, scope, sourceUrl, sourceType, documentKeywords, userKeywords, sessionId: sessionIdOverride, inlineRewrite, forceRewrite, inlineRewriteThreshold }) => {
+        if (!accountId)
+            return refuseNoAccount("memory-ingest");
+        try {
+            const result = await memoryIngest({
+                accountId,
+                attachmentId,
+                conversationIdentity,
+                source,
+                archiveSha256,
+                archiveSourceFile,
+                participantElementIds,
+                lastIngestedMessageHash,
+                lastIngestedMessageAt,
+                archiveTitle,
+                cleanupPriorChunks,
+                sessionIndex,
+                documentSummary,
+                anchorNodeId,
+                anchorLabel,
+                sections,
+                documentEdges,
+                orphanCandidates,
+                scope,
+                sourceUrl,
+                sourceType,
+                documentKeywords,
+                userKeywords,
+                sessionId: resolveSessionId(sessionIdOverride),
+                inlineRewrite,
+                forceRewrite,
+                inlineRewriteThreshold,
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            documentNodeId: result.documentNodeId,
+                            sectionCount: result.sectionCount,
+                            kindBreakdown: result.kindBreakdown,
+                            edgeBreakdown: result.edgeBreakdown,
+                            relatedCount: result.relatedCount,
+                            standaloneCount: result.standaloneCount,
+                            orphanCandidates: result.orphanCandidates,
+                            documentSummary: result.documentSummary,
+                            keywords: result.keywords,
+                            cleanedPriorChunks: result.cleanedPriorChunks,
+                            inlineRewriteCandidates: result.inlineRewriteCandidates,
+                            inlineRewriteDeferred: result.inlineRewriteDeferred,
+                        }),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `memory-ingest failed: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    eagerTool(server, "kd-classify", "Operator-solicited reclassify for any :KnowledgeDocument that carries a `body` property (today: email-thread KDs; future: any thread-shaped source). Reads the KD by attachmentId, decides via a body-growth gate (proceed iff body grew ≥25% since the last classify, or first-ever classify), stages the body to a temp file under $ACCOUNT_DIR/tmp/, and returns a dispatch envelope the admin agent hands to the `librarian` specialist. Librarian runs the document-ingest skill against the temp file; memory-ingest MERGEs by attachmentId, replacing any prior :Section children, and stamps lastClassifiedAt + lastClassifiedBodyLength on the KD so the next gate call has a baseline. Bodyless attachment KDs (PDFs etc.) are not supported here — they have no growth signal.", {
+        attachmentId: z.string().describe("attachmentId of the :KnowledgeDocument to classify. For email threads, this is sha256(`email:<accountId>:<rootMessageId>`)."),
+    }, async ({ attachmentId }) => {
+        if (!accountId)
+            return refuseNoAccount("kd-classify");
+        try {
+            const text = await kdClassify({ accountId, attachmentId });
+            return { content: [{ type: "text", text }] };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `kd-classify failed: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    eagerTool(server, "memory-archive-write", "Bulk-archive write surface for flat datasets. " +
+        "Writes typed entities + natural edges in 500-row UNWIND batches. The Cypher body is fixed " +
+        "server-side per `archiveType`; the agent supplies parsed rows + the discriminant, never " +
+        "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 :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"])
+            .describe("Discriminant naming the per-source schema and Cypher body the server runs. Add a new value here only when the corresponding handler is added in memory-archive-write.ts."),
+        ownerNodeId: z
+            .string()
+            .min(1)
+            .describe("elementId of the archive owner — :AdminUser for an operator's own archive, or :Person for an external-archive owner. Confirmed during the skill's owner-confirmation flow before this tool is invoked."),
+        rows: z
+            .array(z.record(z.string(), z.unknown()))
+            .min(1)
+            .describe("Parsed rows. The skill's selective-ingest gate runs BEFORE this tool — large blanket archives get filtered (Company / Position / Connected On range for linkedin-connections) before the write call."),
+        sessionId: z
+            .string()
+            .optional()
+            .describe("Skill-run UUID for provenance stamping. Falls back to SESSION_ID env var when absent."),
+    }, async ({ archiveType, ownerNodeId, rows, sessionId: sessionIdOverride }) => {
+        if (!accountId)
+            return refuseNoAccount("memory-archive-write");
+        try {
+            const result = await memoryArchiveWrite({
+                archiveType,
+                ownerNodeId,
+                accountId,
+                rows: rows,
+                sessionId: resolveSessionId(sessionIdOverride),
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify(result),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `memory-archive-write failed: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    eagerTool(server, "obsidian-vault-import", "Two-phase server-side ingestion for an extracted Obsidian vault directory. " +
+        "Phase 1 (`mode='dry-run'`) walks the vault, parses pages/wikilinks/tags/attachments, " +
+        "classifies wikilinks against intra-vault pages + existing graph entities (fuzzy match), " +
+        "and returns a plan with any ambiguities the operator must disambiguate. " +
+        "Phase 2 (`mode='commit'`) takes the operator's resolutions, applies content-hash " +
+        "idempotency against existing :KnowledgeDocument nodes, copies attachments to " +
+        "{accountDir}/archive/obsidian/<importId>/, and invokes memory-archive-write with " +
+        "archiveType='obsidian-vault'. The agent never reads or parses markdown — parsing is " +
+        "fully server-side. Routed from the obsidian-import skill under the database-operator " +
+        "specialist; do not call directly from admin chat.", {
+        ownerNodeId: z
+            .string()
+            .min(1)
+            .describe("elementId of the vault owner — :AdminUser for the operator's own vault, :Person for a vault ingested for reference. Confirmed via the skill's owner-confirmation flow before this tool is invoked."),
+        extractedDir: z
+            .string()
+            .min(1)
+            .describe("Absolute path to the extracted vault directory (typically the output of unzip-attachment under <accountDir>/extracted/<id>/). Must be a directory tree of markdown + asset files."),
+        mode: z
+            .enum(["dry-run", "commit"])
+            .describe("`dry-run` returns the resolution plan + ambiguities without writing. `commit` requires the importId returned by the prior dry-run and a `resolutions` map covering every ambiguity."),
+        importId: z
+            .string()
+            .optional()
+            .describe("Stable identifier for the import run. Generated by dry-run; passed back in the commit call so observability lines tie together."),
+        filters: z
+            .object({
+            folderPrefixes: z.array(z.string()).optional()
+                .describe("Vault-relative folder prefixes (with trailing slash optional) to include. Pages outside these prefixes are skipped."),
+            tags: z.array(z.string()).optional()
+                .describe("Tag tokens (without `#`) to filter by. A page must carry at least one to qualify."),
+            modifiedSince: z.string().optional()
+                .describe("ISO 8601 date or epoch-ms. Pages with mtime older than this are skipped."),
+        })
+            .optional()
+            .describe("Selective-ingest filter. The skill's filter conversation drives this — the operator picks folder / tag / modified-since combinations."),
+        resolutions: z
+            .record(z.string(), z.discriminatedUnion("kind", [
+            z.object({ kind: z.literal("page"), obsidianPath: z.string() }),
+            z.object({ kind: z.literal("entity"), nodeId: z.string() }),
+            z.object({ kind: z.literal("stub") }),
+        ]))
+            .optional()
+            .describe("Operator answers to dry-run ambiguities, keyed by the ambiguity id the dry-run returned. Required on commit when ambiguities were reported."),
+        selectiveIngestThreshold: z
+            .number()
+            .int()
+            .positive()
+            .optional()
+            .describe("Page-count threshold above which dry-run sets `selectiveIngestSuggested=true`. Default 100."),
+        sessionId: z
+            .string()
+            .optional()
+            .describe("Skill-run UUID for provenance stamping. Falls back to SESSION_ID env var when absent."),
+    }, async ({ ownerNodeId, extractedDir, mode, importId, filters, resolutions, selectiveIngestThreshold, sessionId: sessionIdOverride, }) => {
+        if (!accountId)
+            return refuseNoAccount("obsidian-vault-import");
+        try {
+            const result = await obsidianVaultImport({
+                accountId,
+                ownerNodeId,
+                extractedDir,
+                mode,
+                importId,
+                filters: filters,
+                resolutions: resolutions,
+                selectiveIngestThreshold,
+                sessionId: resolveSessionId(sessionIdOverride),
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify(result),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `obsidian-vault-import failed: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    // retired the `whatsapp-export-insight-pass` Phase-2 tool
+    // generalised the entire conversation-archive ingest path (no longer
+    // WhatsApp-specific) — see `memory/skills/conversation-archive/` and
+    // `memory/bin/conversation-archive-ingest.{mjs,sh}`. Phase-2 insight
+    // derivation will operate on conversation-document :Section chunks regardless of
+    // source.
+    server.tool("memory-ingest-web", "Adapter for web-content ingestion. Accepts a URL, its pre-fetched readable content " +
+        "(the agent calls WebFetch first, then passes the text here), and the page's editorial title parsed from " +
+        "the HTML `<title>` / `og:title`. Writes the content to a temp file and delegates to memory-ingest-extract — " +
+        "caching the text under a freshly-generated attachmentId. The dispatched specialist then produces typed-section " +
+        "JSON in-turn from the loaded ontology and calls memory-ingest, exactly as for a file upload. " +
+        "Title fallback chain when the caller omits `title`: markdown H1 → URL-derived slug → URL. Body prose is never used as a title. " +
+        "If the URL was previously ingested, returns the existing document info so the agent can inform the user.", {
+        url: z.string().describe("The web page URL being ingested"),
+        content: z.string().describe("The readable text content of the web page (pre-fetched by the agent via WebFetch)"),
+        title: z.string().optional().describe("Editorial page title parsed by the caller from the HTML `<title>` / `og:title` tag. " +
+            "When present, used verbatim as `KnowledgeDocument.name` (capped at 200 chars). " +
+            "When absent, the server falls back to the markdown H1, then a URL-derived slug, then the URL."),
+        scope: z.string().optional().describe("Intended visibility scope (for logging). The actual scope is set when the agent subsequently calls memory-ingest."),
+    }, async ({ url, content, title, scope }) => {
+        if (!accountId)
+            return refuseNoAccount("memory-ingest-web");
+        try {
+            const result = await memoryIngestWeb({
+                accountId,
+                url,
+                content,
+                title,
+                scope,
+            });
+            const response = {
+                attachmentId: result.attachmentId,
+                title: result.title,
+                titleSource: result.titleSource,
+                sourceUrl: url,
+                sourceType: "web",
+                ...result.extract,
+            };
+            if (result.existingDocument) {
+                response.existingDocument = result.existingDocument;
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify(response),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `memory-ingest-web failed: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("memory-find-candidates", "Deterministic bulk-delete selector for Conversation nodes. Returns a structured list of candidates " +
+        "matching a fixed-name filter ('empty' = zero :PART_OF messages; 'single-assistant' = exactly one " +
+        "assistant-role message) and an opaque filterToken. Pair with memory-delete(filterToken=…) — the server " +
+        "re-runs the same predicate per elementId before trashing, so a stale or forged token never deletes. " +
+        "Never author custom delete-selection Cypher for bulk flows; always use this tool.", {
+        filter: z.enum(["empty", "single-assistant"]).describe("Selection predicate. 'empty' = no :PART_OF Messages. 'single-assistant' = exactly one :PART_OF " +
+            "Message with role='assistant'. A content-matching filter ('no-real-user-input') is not yet available."),
+        agentType: z.enum(["admin", "public"]).optional().describe("Scope to conversations matching c.agentType. Omit to scope across both."),
+        limit: z.number().int().positive().optional().describe("Max candidates to return (default 200, hard cap 1000)."),
+        dryRun: z.boolean().optional().describe("Preview matches without minting an actionable filterToken. Candidates are listed in the response, but no delete can be performed against them — caller must re-run without dryRun to receive a token."),
+    }, async ({ filter, agentType, limit, dryRun }) => {
+        if (!accountId)
+            return refuseNoAccount("memory-find-candidates");
+        try {
+            const result = await memoryFindCandidates({ accountId, filter, agentType, limit, dryRun });
+            if (result.items.length === 0) {
+                return { content: [{ type: "text", text: `No candidates matched filter=${filter} agentType=${agentType ?? "any"}. No delete will happen.` }] };
+            }
+            const tokenLine = result.dryRun
+                ? "filterToken=(none — dryRun; re-run without dryRun to get an actionable token)"
+                : `filterToken=${result.filterToken}`;
+            const trailer = result.dryRun
+                ? "This is a dryRun preview. No delete can be performed until you re-run without dryRun."
+                : "Pass each elementId to memory-delete with the filterToken above. The server re-verifies on every call.";
+            const lines = [
+                `Matched ${result.matched} candidate(s) for filter=${filter} agentType=${agentType ?? "any"}.`,
+                tokenLine,
+                "",
+                trailer,
+                "",
+                ...result.items.map((i) => {
+                    const preview = i.firstUserMsgPreview ? ` userPreview=${JSON.stringify(i.firstUserMsgPreview)}` : "";
+                    return `- elementId=${i.elementId} sessionId=${i.sessionId ?? "null"} assistantMsgs=${i.assistantMsgCount} realUserMsgs=${i.realUserMsgCount}${preview}`;
+                }),
+            ];
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `memory-find-candidates failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("memory-node-exists", "Deterministic label-existence check for installer-seeded singleton roots. " +
+        "Returns { exists, elementId, labels } for a single label/accountId lookup, " +
+        "bypassing the memory-search ranking stack so an installer-seeded node with " +
+        "empty content properties (e.g. a freshly seeded :LocalBusiness with no name yet) " +
+        "is still reported as exists=true. Allow-list of labels is fixed: LocalBusiness, " +
+        "AdminUser, UserProfile, Person. Refuses any other label — use memory-search for " +
+        "ranked discovery on general labels. Use this before any branch that claims a " +
+        "singleton root is missing.", {
+        label: z.enum(MEMORY_NODE_EXISTS_LABELS).describe("Installer-seeded singleton label. One of: LocalBusiness, AdminUser, UserProfile, Person."),
+    }, async ({ label }) => {
+        if (!accountId)
+            return refuseNoAccount("memory-node-exists");
+        try {
+            const result = await memoryNodeExists({ accountId, label });
+            const payload = JSON.stringify(result);
+            return { content: [{ type: "text", text: payload }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `memory-node-exists failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("memory-delete", "Soft-delete a single graph node by elementId. Adds the :Trashed label, preserves relationships, " +
+        "and excludes the node from memory-search and any read filtered via notTrashed. For KnowledgeDocument, " +
+        "cascades to linked Section and Chunk children. For Conversation, cascades to attached :PART_OF Messages " +
+        ". Hard removal happens later via memory-empty-trash after the grace period (default 30 days). " +
+        "For bulk-delete flows, pass filterToken from memory-find-candidates — the server re-verifies the predicate " +
+        "before trashing. For GDPR Right-to-Erasure, use contact-erase instead (bypasses this primitive and " +
+        "hard-deletes per Article 17).", {
+        elementId: z.string().describe("Neo4j elementId of the node to trash (from memory-search or memory-find-candidates)."),
+        reason: z.string().optional().describe("Optional human-readable explanation; persisted as trashReason for audit."),
+        filterToken: z.string().optional().describe("Opaque token from memory-find-candidates. Required for bulk-selector flows; the server re-runs the " +
+            "canonical predicate on this elementId before trashing. Omit for single-node deletes where the caller " +
+            "chose the target directly (e.g. from a memory-search result)."),
+    }, async ({ elementId, reason, filterToken }) => {
+        if (!accountId)
+            return refuseNoAccount("memory-delete");
+        try {
+            const result = await memoryDelete({ accountId, elementId, reason, filterToken });
+            const head = result.alreadyTrashed
+                ? `Already trashed: [${result.labels.join(", ")}] elementId=${elementId}`
+                : `Trashed: [${result.labels.join(", ")}] elementId=${elementId}`;
+            const cascade = result.cascade.sections + result.cascade.chunks > 0
+                ? `\nCascaded: ${result.cascade.sections} sections, ${result.cascade.chunks} chunks.`
+                : "";
+            const trail = result.alreadyTrashed
+                ? ""
+                : `\nTrashed at ${result.trashedAt}. Restore via memory-restore; hard removal after grace period via memory-empty-trash.`;
+            return { content: [{ type: "text", text: `${head}${cascade}${trail}` }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `memory-delete failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("memory-restore", "Undo memory-delete on a single graph node by elementId. Removes the :Trashed label and restores " +
+        "snapshotted unique-key properties. For KnowledgeDocument, walks HAS_SECTION/HAS_CHUNK edges to bring " +
+        "trashed children back too. Fails loudly when an active node already holds a unique slot the trashed " +
+        "node needs back (e.g. a fresh LocalBusiness was created while the old one was in trash) — " +
+        "the error names the conflicting elementId so the caller can decide how to resolve.", {
+        elementId: z.string().describe("Neo4j elementId of the trashed node to restore."),
+    }, async ({ elementId }) => {
+        if (!accountId)
+            return refuseNoAccount("memory-restore");
+        try {
+            const result = await memoryRestore({ accountId, elementId });
+            const cascade = result.cascade.sections + result.cascade.chunks > 0
+                ? `\nCascaded: ${result.cascade.sections} sections, ${result.cascade.chunks} chunks.`
+                : "";
+            return {
+                content: [{
+                        type: "text",
+                        text: `Restored: [${result.labels.join(", ")}] elementId=${elementId}${cascade}`,
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `memory-restore failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("memory-empty-trash", "Hard-delete trashed nodes whose trashedAt is older than the grace period (default 30 days). " +
+        "For KnowledgeDocument candidates, also removes the on-disk attachment directory. Use dryRun=true " +
+        "to preview candidates without mutating — the absence of [trash:emptied] log lines after a " +
+        "[trash:empty-run] dryRun=true line is the correct-behaviour signal. Optional labels filter " +
+        "restricts the sweep to a subset of node types (e.g. ['Person']).", {
+        graceDays: z.number().int().min(0).optional().describe("Minimum age in days a trashed node must reach before it's eligible. Default 30."),
+        dryRun: z.boolean().optional().describe("When true, lists candidates without deleting. Default false."),
+        labels: z.array(z.string()).optional().describe("Optional whitelist of node labels — only nodes carrying any of these labels are eligible."),
+    }, async ({ graceDays, dryRun, labels }) => {
+        if (!accountId)
+            return refuseNoAccount("memory-empty-trash");
+        try {
+            const result = await memoryEmptyTrash({ accountId, graceDays, dryRun, labels });
+            const lines = [];
+            lines.push(`Empty-trash run: graceDays=${result.graceDays} dryRun=${result.dryRun} candidates=${result.candidates.length} emptied=${result.emptied} attachmentDirsRemoved=${result.attachmentDirsRemoved}`);
+            if (result.candidates.length > 0 && result.candidates.length <= 25) {
+                for (const c of result.candidates) {
+                    lines.push(`  - [${c.labels.join(", ")}] elementId=${c.elementId} trashedAt=${c.trashedAt} by=${c.trashedBy ?? "unknown"}`);
+                }
+            }
+            else if (result.candidates.length > 25) {
+                lines.push(`  (${result.candidates.length} candidates — too many to list; grep [trash:empty-run]/[trash:emptied] in server.log for detail)`);
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `memory-empty-trash failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("memory-list-attachments", "List stored file attachments for this account with their ingestion status. " +
+        "Returns original filenames, sizes, upload dates, and whether each file has been ingested " +
+        "into the knowledge graph. Does not include web-ingested documents (those have no file on disk).", {}, async () => {
+        if (!accountId)
+            return refuseNoAccount("memory-list-attachments");
+        try {
+            const result = await memoryListAttachments(accountId);
+            if (result.entries.length === 0) {
+                return { content: [{ type: "text", text: "No stored attachments found." }] };
+            }
+            const lines = result.entries.map((e) => {
+                const status = e.softDeleted
+                    ? "deleted (pending purge)"
+                    : e.ingested
+                        ? "ingested"
+                        : "not ingested";
+                const size = e.sizeBytes < 1024
+                    ? `${e.sizeBytes} B`
+                    : e.sizeBytes < 1024 * 1024
+                        ? `${(e.sizeBytes / 1024).toFixed(1)} KB`
+                        : `${(e.sizeBytes / (1024 * 1024)).toFixed(1)} MB`;
+                const idLine = e.elementId
+                    ? `  ID: ${e.attachmentId}  elementId: ${e.elementId}  Stored: ${e.storedAt}`
+                    : `  ID: ${e.attachmentId}  Stored: ${e.storedAt}`;
+                return `${e.filename}  (${e.mimeType}, ${size})  [${status}]\n${idLine}`;
+            });
+            const summary = `${result.totalFiles} files (${result.ingestedCount} ingested${result.skippedCount > 0 ? `, ${result.skippedCount} skipped` : ""})`;
+            return {
+                content: [{ type: "text", text: `${summary}\n\n${lines.join("\n\n")}` }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `memory-list-attachments failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("memory-read-attachment", "Read the content of a stored attachment from disk. Returns the full text for text/markdown files, " +
+        "extracted text for PDFs (via pdftotext), and metadata + HTTP URL for images. " +
+        "Use this to show the user what's in a file or to prepare content for editing.", {
+        attachmentId: z.string().describe("UUID of the attachment to read"),
+    }, async ({ attachmentId }) => {
+        if (!accountId)
+            return refuseNoAccount("memory-read-attachment");
+        try {
+            const result = await memoryReadAttachment(accountId, attachmentId);
+            let text = `**${result.filename}** (${result.mimeType}, ${result.sizeBytes} bytes)\nStored: ${result.storedAt}\n`;
+            if (result.contentNote)
+                text += `\n_${result.contentNote}_\n`;
+            if (result.httpUrl)
+                text += `\nURL: ${result.httpUrl}\n`;
+            if (result.content)
+                text += `\n---\n\n${result.content}`;
+            return { content: [{ type: "text", text }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `memory-read-attachment failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("memory-edit-attachment", "Edit a stored text/markdown attachment in place. Replaces the file content on disk, updates the " +
+        "metadata timestamp, and re-extracts the file for chunking (populating the extract cache). " +
+        "After this call, use memory-ingest with updated summaries to sync the knowledge graph. " +
+        "Only text/plain and text/markdown files are editable — PDFs and images are rejected.", {
+        attachmentId: z.string().describe("UUID of the attachment to edit"),
+        content: z.string().describe("The full replacement text content"),
+    }, async ({ attachmentId, content }) => {
+        if (!accountId)
+            return refuseNoAccount("memory-edit-attachment");
+        try {
+            const result = await memoryEditAttachment({ accountId, attachmentId, content });
+            let text = `Edited: ${result.filename} (${result.oldSizeBytes} → ${result.newSizeBytes} bytes)`;
+            if (result.cachePopulated) {
+                text += `\nExtract cache populated: ${result.extractTextLength} chars.`;
+                text += `\nProduce typed-section JSON in-turn from the loaded ontology and call memory-ingest to re-sync the knowledge graph.`;
+            }
+            else {
+                text += `\nWARNING: File updated on disk but extract cache could not be populated.`;
+                text += `\nCall memory-ingest-extract manually, then produce typed-section JSON in-turn and call memory-ingest.`;
+            }
+            return { content: [{ type: "text", text }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `memory-edit-attachment failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("memory-rename-attachment", "Rename a stored attachment. Updates the filename in the .meta.json sidecar and the " +
+        "KnowledgeDocument name in Neo4j (if the file has been ingested). The file on disk " +
+        "is not renamed — it uses UUID-based naming. Only the human-readable metadata changes.", {
+        attachmentId: z.string().describe("UUID of the attachment to rename"),
+        newFilename: z.string().describe("The new filename (e.g. 'quarterly-report-q1.pdf')"),
+    }, async ({ attachmentId, newFilename }) => {
+        if (!accountId)
+            return refuseNoAccount("memory-rename-attachment");
+        try {
+            const result = await memoryRenameAttachment({ accountId, attachmentId, newFilename });
+            if (result.oldFilename === result.newFilename) {
+                return { content: [{ type: "text", text: `Filename unchanged: "${result.newFilename}"` }] };
+            }
+            let text = `Renamed: "${result.oldFilename}" → "${result.newFilename}"`;
+            text += result.graphUpdated
+                ? `\nKnowledge graph updated.`
+                : `\nNo KnowledgeDocument in graph (file not yet ingested — metadata only).`;
+            return { content: [{ type: "text", text }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `memory-rename-attachment failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    // --- conversation-list formatting helpers ---
+    /** Strip Neo4j DateTime timezone ID bracket (e.g. "[UTC]", "[Europe/London]") that Date.parse rejects. */
+    function cleanNeo4jIso(isoStr) {
+        return isoStr.replace(/\[.*\]$/, "");
+    }
+    /** Format an ISO timestamp to short human-readable form: "YYYY-MM-DD HH:MM UTC". Empty string if invalid. */
+    function shortIso(isoStr) {
+        if (!isoStr)
+            return "";
+        const ms = Date.parse(cleanNeo4jIso(isoStr));
+        if (!Number.isFinite(ms))
+            return "";
+        return new Date(ms).toISOString().replace("T", " ").slice(0, 16) + " UTC";
+    }
+    /** Compute relative time string from an ISO timestamp. Returns null for >= 7 days or invalid input. */
+    function relativeTime(isoStr) {
+        if (!isoStr)
+            return null;
+        const ms = Date.parse(cleanNeo4jIso(isoStr));
+        if (!Number.isFinite(ms))
+            return null;
+        const diffMs = Date.now() - ms;
+        if (diffMs < 60_000)
+            return "just now"; // includes future timestamps (clock drift)
+        const mins = Math.floor(diffMs / 60_000);
+        if (mins < 60)
+            return `${mins}m ago`;
+        const hours = Math.floor(mins / 60);
+        if (hours < 24)
+            return `${hours}h ago`;
+        const days = Math.floor(hours / 24);
+        if (days < 7)
+            return `${days}d ago`;
+        return null;
+    }
+    /** Format conversation header line with activity timestamps. Shared across metadata and inline modes. */
+    function formatConversationHeader(opts) {
+        const label = opts.name ? `"${opts.name}"` : opts.sessionId.slice(0, 8) + "…";
+        const agentInfo = opts.agentSlug ? `${opts.agentType}/${opts.agentSlug}` : opts.agentType;
+        const createdStr = shortIso(opts.createdAt) || "(no timestamp)";
+        const updatedStr = shortIso(opts.updatedAt);
+        if (!updatedStr) {
+            return `${label} [${agentInfo}] · created ${createdStr} · (activity unknown) — ${opts.messageCount} messages`;
+        }
+        const createdMs = Date.parse(cleanNeo4jIso(opts.createdAt));
+        const updatedMs = Date.parse(cleanNeo4jIso(opts.updatedAt));
+        if (Number.isFinite(createdMs) && Number.isFinite(updatedMs) && Math.abs(updatedMs - createdMs) < 1000) {
+            const ago = relativeTime(opts.updatedAt);
+            const agoStr = ago ? ` (${ago})` : "";
+            return `${label} [${agentInfo}] · created ${createdStr}${agoStr} — ${opts.messageCount} messages`;
+        }
+        const ago = relativeTime(opts.updatedAt);
+        const agoStr = ago ? ` (${ago})` : "";
+        return `${label} [${agentInfo}] · created ${createdStr} · active ${updatedStr}${agoStr} — ${opts.messageCount} messages`;
+    }
+    server.tool("conversation-list", "List conversations or retrieve messages from a specific conversation. " +
+        "Without sessionId: lists all conversations with message counts, ordered by most recent activity (updatedAt DESC). " +
+        "Headers show both creation time and last activity time; when they differ, the conversation was resumed. " +
+        "With sessionId: returns all messages in that conversation chronologically with per-message timestamps. " +
+        "With includeMessages: returns conversations with their timestamped messages inline (useful for batch review). " +
+        "The since filter matches against activity time (updatedAt), not creation time.", {
+        sessionId: z
+            .string()
+            .optional()
+            .describe("If provided, returns messages for this conversation. If omitted, lists all conversations."),
+        agentType: z
+            .string()
+            .optional()
+            .describe("Filter conversations by agent type ('admin' or 'public'). Only applies when listing conversations."),
+        agentSlug: z
+            .string()
+            .optional()
+            .describe("Filter conversations by public agent slug (e.g. 'maxy-assistant'). Only applies when listing conversations."),
+        since: z
+            .string()
+            .optional()
+            .describe("ISO 8601 timestamp. Only return conversations with activity (updatedAt) at or after this time. Only applies when listing conversations."),
+        includeMessages: z
+            .boolean()
+            .optional()
+            .describe("When true, include message content inline with each conversation (max 50 messages per conversation). Only applies when listing conversations."),
+        limit: z
+            .number()
+            .optional()
+            .describe("Maximum results (default 50 for conversations, 200 for messages)"),
+    }, async ({ sessionId, agentType, agentSlug, since, includeMessages, limit }) => {
+        if (!accountId)
+            return refuseNoAccount("conversation-list");
+        const startTime = Date.now();
+        const dbSession = getSession();
+        try {
+            if (sessionId) {
+                // Messages mode — chronological listing for a specific conversation
+                const messageLimit = limit ?? 200;
+                const result = await dbSession.run(`MATCH (m:Message)-[:PART_OF]->(c:Conversation {sessionId: $sessionId, accountId: $accountId})
+             WHERE ${notTrashed("m")} AND ${notTrashed("c")}
+             RETURN m.role AS role, m.content AS content, m.createdAt AS createdAt
+             ORDER BY m.createdAt ASC
+             LIMIT $limit`, { sessionId, accountId, limit: int(messageLimit) });
+                if (result.records.length === 0) {
+                    return {
+                        content: [{ type: "text", text: "No messages found for this conversation." }],
+                    };
+                }
+                const formatted = result.records.map((r) => {
+                    const role = String(r.get("role") ?? "unknown");
+                    const content = String(r.get("content") ?? "");
+                    const ts = shortIso(String(r.get("createdAt") ?? ""));
+                    return ts ? `[${role} ${ts}]\n  ${content}` : `[${role}]\n  ${content}`;
+                });
+                process.stderr.write(`[conversation-list] [${accountId}] mode=messages sessionId=${sessionId.slice(0, 8)}… count=${result.records.length} (${Date.now() - startTime}ms)\n`);
+                return {
+                    content: [{ type: "text", text: formatted.join("\n---\n") }],
+                };
+            }
+            // List mode — all conversations with message counts (or inline messages)
+            const convLimit = limit ?? (includeMessages ? 20 : 50);
+            const whereClauses = [];
+            if (agentType)
+                whereClauses.push("c.agentType = $agentType");
+            if (agentSlug)
+                whereClauses.push("c.agentSlug = $agentSlug");
+            if (since)
+                whereClauses.push("c.updatedAt >= datetime($since)");
+            const whereStr = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+            const params = {
+                accountId,
+                limit: int(convLimit),
+                ...(agentType ? { agentType } : {}),
+                ...(agentSlug ? { agentSlug } : {}),
+                ...(since ? { since } : {}),
+            };
+            if (includeMessages) {
+                // Inline messages mode — conversations with message content
+                const msgLimit = 50;
+                const trashedConvFilter = notTrashed("c");
+                const trashedMsgFilter = notTrashed("m");
+                const result = await dbSession.run(`MATCH (c:Conversation {accountId: $accountId})
+             ${whereStr ? whereStr + " AND " : "WHERE "}${trashedConvFilter}
+             WITH c ORDER BY c.updatedAt DESC LIMIT $limit
+             OPTIONAL MATCH (m:Message)-[:PART_OF]->(c) WHERE ${trashedMsgFilter}
+             WITH c, m ORDER BY m.createdAt ASC
+             WITH c, collect({role: m.role, content: m.content, createdAt: m.createdAt})[0..${msgLimit}] AS messages
+             RETURN c.sessionId AS sessionId,
+                    c.agentType AS agentType,
+                    c.agentSlug AS agentSlug,
+                    c.name AS name,
+                    c.createdAt AS createdAt,
+                    c.updatedAt AS updatedAt,
+                    size(messages) AS messageCount,
+                    messages
+             ORDER BY c.updatedAt DESC`, params);
+                if (result.records.length === 0) {
+                    return {
+                        content: [{ type: "text", text: "No conversations found." }],
+                    };
+                }
+                const formatted = result.records.map((r) => {
+                    const id = String(r.get("sessionId") ?? "");
+                    const msgCount = Number(r.get("messageCount") ?? 0);
+                    const header = formatConversationHeader({
+                        name: r.get("name"),
+                        sessionId: id,
+                        agentType: String(r.get("agentType") ?? ""),
+                        agentSlug: r.get("agentSlug"),
+                        createdAt: String(r.get("createdAt") ?? ""),
+                        updatedAt: String(r.get("updatedAt") ?? ""),
+                        messageCount: msgCount,
+                    });
+                    const messages = r.get("messages");
+                    const validMessages = (messages || []).filter((m) => m.role != null);
+                    if (validMessages.length === 0) {
+                        return `### ${header}\n  (no messages)`;
+                    }
+                    let missingTs = 0;
+                    const msgLines = validMessages.map((m) => {
+                        const role = String(m.role);
+                        const content = String(m.content ?? "");
+                        const ts = shortIso(String(m.createdAt ?? ""));
+                        if (!ts)
+                            missingTs++;
+                        return ts ? `[${role} ${ts}] ${content}` : `[${role}] ${content}`;
+                    });
+                    const footer = missingTs > 0 ? `\n(${missingTs} message${missingTs > 1 ? "s" : ""} had no timestamp)` : "";
+                    return `### ${header}\n${msgLines.join("\n")}${footer}`;
+                });
+                process.stderr.write(`[conversation-list] [${accountId}] mode=inline agentType=${agentType ?? "all"} agentSlug=${agentSlug ?? "all"} since=${since ?? "none"} count=${result.records.length} (${Date.now() - startTime}ms)\n`);
+                return {
+                    content: [{ type: "text", text: formatted.join("\n\n") }],
+                };
+            }
+            // Metadata mode — conversations with message counts only
+            const trashedConvFilter = notTrashed("c");
+            const trashedMsgFilter = notTrashed("m");
+            const result = await dbSession.run(`MATCH (c:Conversation {accountId: $accountId})
+           ${whereStr ? whereStr + " AND " : "WHERE "}${trashedConvFilter}
+           WITH c ORDER BY c.updatedAt DESC LIMIT $limit
+           OPTIONAL MATCH (m:Message)-[:PART_OF]->(c) WHERE ${trashedMsgFilter}
+           RETURN c.sessionId AS sessionId,
+                  c.agentType AS agentType,
+                  c.agentSlug AS agentSlug,
+                  c.name AS name,
+                  c.createdAt AS createdAt,
+                  c.updatedAt AS updatedAt,
+                  count(m) AS messageCount
+           ORDER BY c.updatedAt DESC`, params);
+            if (result.records.length === 0) {
+                return {
+                    content: [{ type: "text", text: "No conversations found." }],
+                };
+            }
+            const formatted = result.records.map((r) => {
+                const id = String(r.get("sessionId") ?? "");
+                const msgCount = typeof r.get("messageCount") === "number"
+                    ? r.get("messageCount")
+                    : Number(r.get("messageCount"));
+                return formatConversationHeader({
+                    name: r.get("name"),
+                    sessionId: id,
+                    agentType: String(r.get("agentType") ?? ""),
+                    agentSlug: r.get("agentSlug"),
+                    createdAt: String(r.get("createdAt") ?? ""),
+                    updatedAt: String(r.get("updatedAt") ?? ""),
+                    messageCount: msgCount,
+                });
+            });
+            process.stderr.write(`[conversation-list] [${accountId}] mode=list agentType=${agentType ?? "all"} agentSlug=${agentSlug ?? "all"} since=${since ?? "none"} count=${result.records.length} (${Date.now() - startTime}ms)\n`);
+            return {
+                content: [{ type: "text", text: formatted.join("\n") }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `conversation-list failed: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        finally {
+            await dbSession.close();
+        }
+    });
+    server.tool("profile-update", "Create, update, or reinforce a user preference; set top-level UserProfile fields (timezone, locale, givenName, role, expertise) via profileFields; AND set operator-identity fields (email, telephone) on the operator's personal-profile Person via personFields. Person is the canonical operator-identity store; UserProfile carries preferences and behavioural state only. Supports modes: reinforce (re-observed, boost confidence), update (value changed), contradict (value contradicts prior), merge (combine overlapping preferences).", {
+        category: z.enum(["communication", "scheduling", "decision", "workflow", "content", "interaction"])
+            .describe("Preference category"),
+        key: z.string().describe("Preference identifier (e.g. 'response_length', 'meeting_time')"),
+        value: z.string().describe("The preference value (e.g. 'terse', 'never before 10am')"),
+        source: z.enum(["explicit", "behavioural"]).optional()
+            .describe("How the preference was observed. Defaults to 'behavioural'."),
+        mode: z.enum(["reinforce", "update", "contradict", "merge"]).optional()
+            .describe("Update mode. Defaults to 'reinforce'."),
+        sessionId: z.string().optional()
+            .describe("Conversation ID for evidence linking"),
+        profileFields: z.record(z.string(), z.unknown()).optional()
+            .describe("Top-level UserProfile fields to update (e.g. timezone, locale, role)"),
+        personFields: z.object({
+            email: z.string().optional(),
+            telephone: z.string().optional(),
+        }).optional()
+            .describe("Operator-identity fields written to the OWNS-bound Person. Use canonical `telephone` (NOT `phone` — that is the schema synonym, not the canonical name). Tool throws if the AdminUser-OWNS-Person edge is missing rather than silently no-op."),
+        mergeSourceIds: z.array(z.string()).optional()
+            .describe("For mode 'merge': preferenceIds of sources to combine into this preference"),
+    }, async ({ category, key, value, source, mode, sessionId, profileFields, personFields, mergeSourceIds }) => {
+        if (!accountId)
+            return refuseNoAccount("profile-update");
+        try {
+            if (!userId) {
+                return { content: [{ type: "text", text: "profile-update requires an authenticated admin session with userId" }], isError: true };
+            }
+            const result = await profileUpdate({
+                accountId,
+                userId,
+                category,
+                key,
+                value,
+                source,
+                mode,
+                sessionId,
+                profileFields: profileFields,
+                personFields,
+                mergeSourceIds,
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: `Preference ${result.action}: ${category}/${key} (confidence: ${result.confidence.toFixed(2)}${result.mergedCount ? `, merged ${result.mergedCount} sources` : ""})`,
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `profile-update failed: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("profile-delete", "Soft-delete a specific user preference (marks :Trashed, restorable via memory-restore within the grace period; permanently removed later by memory-empty-trash). Use when the owner says 'forget that' or 'don't remember X'. Idempotent — succeeds even if the preference doesn't exist.", {
+        category: z.enum(["communication", "scheduling", "decision", "workflow", "content", "interaction"])
+            .describe("Preference category"),
+        key: z.string().describe("Preference key to delete"),
+    }, async ({ category, key }) => {
+        if (!accountId)
+            return refuseNoAccount("profile-delete");
+        try {
+            if (!userId) {
+                return { content: [{ type: "text", text: "profile-delete requires an authenticated admin session with userId" }], isError: true };
+            }
+            const result = await profileDelete({ accountId, userId, category, key });
+            return {
+                content: [{
+                        type: "text",
+                        text: result.deleted
+                            ? `Deleted preference: ${category}/${key}`
+                            : `No preference found for ${category}/${key} — nothing to delete.`,
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `profile-delete failed: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    // profile-read contains owner PII (name, role, timezone, preferences) —
+    // admin-only, not exposed to the public agent.
+    server.tool("profile-read", "Read the business owner's profile and preferences. Returns preferences grouped by category (communication, scheduling, decisions, workflow, content, interaction). " +
+        "With detail=true: includes per-preference confidence scores, evidence trail (which conversations the preference was observed in), source (explicit vs behavioural), and summary statistics. " +
+        "Use detail=true when the owner asks 'what do you know about me?' or when reviewing memory accuracy.", {
+        detail: z.boolean().optional().describe("When true, returns per-preference confidence, source, evidence trail, and memory statistics. " +
+            "Default false returns a compact summary for system prompt injection."),
+    }, async ({ detail }) => {
+        if (!accountId)
+            return refuseNoAccount("profile-read");
+        try {
+            if (!userId) {
+                return { content: [{ type: "text", text: "profile-read requires an authenticated admin session with userId" }], isError: true };
+            }
+            const result = await profileRead({ accountId, userId, detail: detail ?? false });
+            return {
+                content: [{ type: "text", text: result.summary }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `profile-read failed: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // memory-brain-capture-recent: read-only diagnostic for the graph writes
+    // admin dispatches to `database-operator` (inline mid-turn, plus the
+    // on-demand `/insight` graph-completeness sweep).
+    // Returns recent :MENTIONS edges (:Message-[:MENTIONS]->Entity) and
+    // :Idea nodes filtered by r.createdByAgent='database-operator'. The
+    // admin agent uses this to answer "what has the brain captured today?"
+    // without touching cypher. Task 439.
+    server.tool("memory-brain-capture-recent", "Read the most recent per-turn graph-pass writes for this account: entity mentions extracted from operator messages, and original-thinking :Idea nodes. " +
+        "Default window is the last 24 hours. " +
+        "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?'.", {
+        windowHours: z.number().int().optional().describe("Hours back from now. Default 24. Capped at 720 (30 days)."),
+        limit: z.number().int().optional().describe("Max rows returned. Default 50, max 200."),
+    }, async ({ windowHours, limit }) => {
+        try {
+            if (!accountId)
+                return refuseNoAccount("memory-brain-capture-recent");
+            const result = await memoryBrainCaptureRecent({ accountId, windowHours, limit });
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `memory-brain-capture-recent failed: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    // -------------------------------------------------------------------------
+    // Deny-list maintenance + conversation-memory expunge.
+    //
+    // The deny-list is operator-curated storage of "never surface these
+    // substrings" signal. Nothing auto-applies it — no cron, no bulk engine.
+    // The admin agent reads the list and applies discretion per case via
+    // memory-update, memory-delete, or conversation-memory-expunge. This
+    // replaces the removed graph-prune autonomous rule engine whose
+    // orphan-delete rule wiped 19 nodes on 2026-04-20.
+    // -------------------------------------------------------------------------
+    server.tool("graph-prune-denylist-add", "Add one or more strings to the operator-curated deny-list. The list is a stored signal — no cron, no " +
+        "autonomous sweep. The admin agent reads the list and decides per case whether to null a property " +
+        "via memory-update, remove a node via memory-delete, or scrub a conversation's :Memory via " +
+        "conversation-memory-expunge. Use to record poisonous substrings (retired domain names, wrong " +
+        "account ids, fabricated identifiers) that you want the agent to watch for. The list is shared " +
+        "per-device and survives upgrades.", {
+        values: z.array(z.string().min(1)).min(1).describe("Substring values to add. Match is exact substring (case-sensitive) against string-typed properties only."),
+    }, async ({ values }) => {
+        if (!accountId)
+            return refuseNoAccount("graph-prune-denylist-add");
+        try {
+            const result = await graphPruneDenylistAdd(values);
+            const lines = [
+                `Added ${result.added.length} entries to deny-list (total ${result.totalAfter}).`,
+            ];
+            if (result.added.length > 0)
+                lines.push(`Added: ${result.added.join(", ")}`);
+            if (result.skipped.length > 0)
+                lines.push(`Already present (skipped): ${result.skipped.join(", ")}`);
+            lines.push("No autonomous sweep — apply discretion via memory-update / memory-delete / conversation-memory-expunge on reads that surface matching content.");
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `graph-prune-denylist-add failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("graph-prune-denylist-remove", "Remove one or more strings from the operator-curated deny-list. Entries no longer serve as signal " +
+        "for the admin agent. Any property values previously nulled via manual memory-update calls are not " +
+        "restored — audit entries on each affected node remain for forensic review.", {
+        values: z.array(z.string().min(1)).min(1).describe("Substring values to remove (must match exactly as previously added)."),
+    }, async ({ values }) => {
+        if (!accountId)
+            return refuseNoAccount("graph-prune-denylist-remove");
+        try {
+            const result = await graphPruneDenylistRemove(values);
+            const lines = [
+                `Removed ${result.removed.length} entries from deny-list (total ${result.totalAfter}).`,
+            ];
+            if (result.removed.length > 0)
+                lines.push(`Removed: ${result.removed.join(", ")}`);
+            if (result.notFound.length > 0)
+                lines.push(`Not present (skipped): ${result.notFound.join(", ")}`);
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `graph-prune-denylist-remove failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("conversation-memory-expunge", "Remove deny-listable content from a specific conversation's :Memory nodes by manually-supplied " +
+        "substring pattern. Targets :Memory nodes linked to the named Conversation; nulls every string property " +
+        "whose value contains the pattern, with an audit entry on each affected node. The conversation transcript " +
+        "(Message nodes) is immutable history and is never modified — only the derived :Memory payload that " +
+        "memory-search would otherwise re-surface. Use when a single conversation polluted memory with claims " +
+        "that should not propagate (e.g. wrong-account hostnames, fabricated identifiers).", {
+        sessionId: z.string().min(1).describe("The Conversation node's sessionId to scope the expunge to."),
+        pattern: z.string().min(1).describe("The substring to scrub from string properties on linked :Memory nodes."),
+    }, async ({ sessionId, pattern }) => {
+        if (!accountId)
+            return refuseNoAccount("conversation-memory-expunge");
+        try {
+            const result = await conversationMemoryExpunge({ accountId, sessionId, pattern });
+            const lines = [
+                `Expunged "${result.pattern}" from conversation ${result.sessionId.slice(0, 8)}…`,
+                `:Memory nodes scanned: ${result.nodesScanned}`,
+                `Properties nulled: ${result.propertiesNulled}`,
+            ];
+            if (result.affectedNodeIds.length > 0 && result.affectedNodeIds.length <= 25) {
+                lines.push(`Affected node ids: ${result.affectedNodeIds.join(", ")}`);
+            }
+            else if (result.affectedNodeIds.length > 25) {
+                lines.push(`Affected node ids: ${result.affectedNodeIds.length} nodes (too many to list — see graph-prune.log for [graph:prune:action] entries).`);
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `conversation-memory-expunge failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+}
+// graph-prune-denylist-list and conversation-search are read-only — available regardless of readOnly mode.
+server.tool("graph-prune-denylist-list", "List the current operator-curated deny-list values used by the daily graph-prune cron. " +
+    "Returns the substring values, the timestamp of the last edit, and the total count.", {}, () => {
+    if (!accountId)
+        return refuseNoAccount("graph-prune-denylist-list");
+    try {
+        const result = graphPruneDenylistList();
+        if (result.count === 0) {
+            return { content: [{ type: "text", text: "Deny-list is empty. Use graph-prune-denylist-add to seed entries." }] };
+        }
+        const text = `Deny-list (${result.count} entries, updated ${result.updatedAt}):\n${result.values.map((v) => `  - ${v}`).join("\n")}`;
+        return { content: [{ type: "text", text }] };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `graph-prune-denylist-list failed: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+});
+// conversation-search is read-only — available regardless of readOnly mode.
+// When SESSION_ID is set (public agent), results are scoped to that conversation only.
+eagerTool(server, "conversation-search", "Search conversation history using semantic vector search. Returns relevant past messages, ordered by relevance. Use this to recall specific past interactions.", {
+    query: z.string().describe("Natural language search query"),
+    limit: z
+        .number()
+        .optional()
+        .describe("Maximum number of results (default 10)"),
+}, async ({ query, limit: maxResults }) => {
+    if (!accountId)
+        return refuseNoAccount("conversation-search");
+    try {
+        const queryEmbedding = await embed(query);
+        const resultLimit = maxResults ?? 10;
+        const dbSession = getSession();
+        try {
+            const conversationSessionId = resolveSessionId();
+            const sessionClause = conversationSessionId
+                ? "AND node.sessionId = $sessionId"
+                : "";
+            const result = await dbSession.run(`CALL db.index.vector.queryNodes('message_embedding', $limit, $embedding)
+           YIELD node, score
+           WHERE node.accountId = $accountId
+           ${sessionClause}
+           AND ${notTrashed("node")}
+           WITH node, score
+           OPTIONAL MATCH (node)-[:PART_OF]->(c:Conversation) WHERE ${notTrashed("c")}
+           RETURN node.messageId AS messageId,
+                  node.role AS role,
+                  node.content AS content,
+                  node.sessionId AS sessionId,
+                  c.name AS sessionName,
+                  node.createdAt AS createdAt,
+                  score
+           ORDER BY score DESC
+           LIMIT $limit`, {
+                embedding: queryEmbedding,
+                limit: int(resultLimit),
+                accountId,
+                ...(conversationSessionId ? { sessionId: conversationSessionId } : {}),
+            });
+            if (result.records.length === 0) {
+                return {
+                    content: [{ type: "text", text: "No conversation history found for this query." }],
+                };
+            }
+            const formatted = result.records.map((r) => {
+                const role = r.get("role");
+                const content = r.get("content");
+                const score = typeof r.get("score") === "number" ? r.get("score") : Number(r.get("score"));
+                const createdAt = String(r.get("createdAt"));
+                const convId = r.get("sessionId");
+                const sessionName = r.get("sessionName");
+                const convPrefix = convId ? convId.slice(0, 8) : "unknown";
+                const convLabel = sessionName
+                    ? `[conv:${convPrefix} "${sessionName}"]`
+                    : `[conv:${convPrefix}]`;
+                return `${convLabel} [${role}] (score: ${score.toFixed(3)}, ${createdAt})\n  ${content}`;
+            });
+            // Diagnostic: log when admin search results span multiple conversations
+            const distinctConvIds = new Set(result.records
+                .map((r) => r.get("sessionId"))
+                .filter(Boolean));
+            if (distinctConvIds.size > 1) {
+                const prefixes = [...distinctConvIds].map((id) => id.slice(0, 8));
+                process.stderr.write(`[conversation-search] [${accountId}] results span ${distinctConvIds.size} conversations: ${prefixes.join(", ")} (query: ${query.slice(0, 80)})\n`);
+            }
+            return {
+                content: [{ type: "text", text: formatted.join("\n---\n") }],
+            };
+        }
+        finally {
+            await dbSession.close();
+        }
+    }
+    catch (err) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Conversation search failed: ${err instanceof Error ? err.message : String(err)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// image-fetch — return a remote image URL as a vision-capable content block.
+// Built for the listing-curator specialist's per-image vision pass; useful to
+// any caller that has an image URL in hand and a model that can see images.
+// Specialist tool, not in ADMIN_CORE_TOOLS — registered via server.tool, not
+// eagerTool (deferred-by-default ToolSearch tax is acceptable because the
+// curator is the only routine caller).
+server.tool("image-fetch", [
+    "Fetch a remote image URL and return its bytes as an inline image content block the model can see.",
+    "Guards: http/https only, content-type must start with image/, 10 MB byte cap, 30 s timeout.",
+    "Returns one text block summarising the fetch plus one image block on success; one text block with isError on failure.",
+].join(" "), {
+    url: z.string().describe("Absolute http(s) URL of the image to fetch."),
+}, async ({ url }) => {
+    const result = await fetchImageAsContent(url);
+    if (!result.ok) {
+        return {
+            content: [{ type: "text", text: `image-fetch failed: ${result.reason}` }],
+            isError: true,
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Fetched ${result.bytes} bytes (${result.mimeType}) from ${url}`,
+            },
+            {
+                type: "image",
+                data: result.base64,
+                mimeType: result.mimeType,
+            },
+        ],
+    };
+});
+// ===================================================================
+// Typed-edge auto-extraction pass (Task 305)
+// ===================================================================
+//
+// Schema-bounded pass that reads prose-bearing nodes the operator's account
+// wrote since `sinceIso` and asks Haiku for typed-edge proposals against
+// `TYPED_EDGE_ALLOWLIST`. Owned by `database-operator`
+// (admin Task-spawns it during an on-demand `/insight` pass); NOT in
+// `ADMIN_CORE_TOOLS`. Backfill is via the CLI under `scripts/backfill-typed-edges.ts`,
+// bypassing this tool.
+server.tool("memory-typed-edge-pass", "Run the typed-edge auto-extraction pass over prose-bearing nodes this account wrote since sinceIso. Reads Message/Page/Meeting/Email/Idea/Note/Post/Report nodes, batches them, asks Haiku for typed-edge proposals against the closed allowlist (ATTENDED, WORKS_AT, INVESTED_IN, FOUNDED, ADVISES, MENTIONS, AUTHORED, ATTACHED_TO, REFERENCES), validates each proposal inline, and MERGEs accepted edges with createdBy provenance. Returns the counters (nodes, proposed, accepted, rejected, failed, ms) for the caller to hand back to admin for its insight-pass summary.", {
+    sinceIso: z.string().describe("ISO timestamp lower bound. Prose nodes with updatedAt >= sinceIso are processed."),
+    sessionId: z.string().optional().describe("Conversation id stamped onto the createdBy provenance of MERGEd edges. Defaults to SESSION_ID env if absent."),
+}, async (args) => {
+    if (!accountId)
+        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: [{
+                    type: "text",
+                    text: JSON.stringify(result),
+                }],
+        };
+    }
+    catch (err) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Typed-edge pass failed: ${err instanceof Error ? err.message : String(err)}`,
+                }],
+            isError: true,
+        };
+    }
+    finally {
+        await dbSession.close();
+    }
+});
+// ===================================================================
+// Dream-cycle (Task 327, absorbs 330)
+// ===================================================================
+// Report MCP tools (Task 332) are registered earlier in this file.
+// Dream-run calls the same writer in-process for the per-run :Report.
+server.tool("memory-dream-run", "Operator-initiated dream-cycle: graph-hygiene sweep across seven phases " +
+    "(orphan detection, stale compiled-truth, edges to :Trashed targets, citation audit on :TimelineEvent, " +
+    "prune compiled-truth revisions, materialise :BACKLINKS edges, tag normalisation). " +
+    "Writes a :Report node at the end. Failure of any phase logs and continues. " +
+    "Pass phases=[4] to run only the citation audit (e.g. after a bulk ingest), phases=[5] for revision prune only, " +
+    "or phases=[6,7] for backlink/tag maintenance only.", {
+    operatorId: z.string().optional().describe("Identifier of the operator who triggered the run; appears in the report and log line."),
+    phases: z.array(z.number().int().min(1).max(7)).optional().describe("Subset of phases to run. Default [1,2,3,4,5,6,7]. Order is fixed."),
+    maxEventsPerRun: z.number().int().positive().optional().describe("Phase 4 cap on :TimelineEvent rows scanned per run. Default 200."),
+}, async ({ operatorId, phases, maxEventsPerRun }) => {
+    if (!accountId)
+        return refuseNoAccount("memory-dream-run");
+    try {
+        const result = await memoryDreamRun({ accountId, operatorId, phases, maxEventsPerRun });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `memory-dream-run failed: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+});
+server.tool("memory-review-queue", "Read-only summary of the dream-cycle's review queues (:OrphanCandidate, :CitationProposal). " +
+    "Returns per-queue counts and a small sample so the operator can see whether to triage.", {
+    sampleSize: z.number().int().positive().optional().describe("Sample rows per queue. Default 5, max 25."),
+}, async ({ sampleSize }) => {
+    if (!accountId)
+        return refuseNoAccount("memory-review-queue");
+    try {
+        const result = await memoryReviewQueue({ accountId, sampleSize });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `memory-review-queue failed: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+});
+// Cleanup on exit
+process.on("SIGINT", async () => {
+    liveSchemaRuntime.cache.stop();
+    await closeDriver();
+    process.exit(0);
+});
+const transport = new StdioServerTransport();
+await server.connect(transport);
+//# sourceMappingURL=index.js.map