@rubytech/create-maxy-code 0.1.151 → 0.1.152

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

@@ -1,13 +1,10 @@
 ---
 name: memory
-description: "Graph memory plugin. Provides memory-search (with optional `fields` projection for known-shape lookups), memory-rank, memory-write, memory-update, and the :Report surface (memory-report-write / memory-report-read-latest / memory-report-list) for reading from, writing to, and updating the Neo4j knowledge graph. Includes conversational memory — organic preference learning, evidence-backed recall, and transparent 'what do you know about me?' responses. Document ingestion (memory-classify + memory-ingest) supports two modes: `document` (default) for unstructured PDF/web content → :KnowledgeDocument (keyed on `attachmentId`) + :Section, and `chat` for conversation transcripts → :ConversationArchive (Task 397, keyed on `conversationIdentity`) + :Section chunks; two parent labels, two writer paths chosen by which identity property is set. Conversation-archive Phase 2 (`conversation-archive-derive-insights`) walks chunks of one named archive and emits per-row claim proposals for operator-gated wiring; `conversation-archive-enrich-rejection` records (or undoes) durable per-row rejections so already-triaged claims do not re-surface on re-runs. Ships four skills: `conversational-memory`, `document-ingest`, `conversation-archive` (source-agnostic transcript ingest for WhatsApp, Telegram, Signal, LinkedIn DMs, Zoom, meeting minutes, iMessage, Slack), and `conversation-archive-enrich` (per-row operator-gated insight derivation over a named archive's chunks)."
+description: "Graph memory plugin. Provides memory-search (with optional `fields` projection for known-shape lookups), memory-write, memory-update, and the :Report surface (memory-report-write / memory-report-read-latest / memory-report-list) for reading from, writing to, and updating the Neo4j knowledge graph. Includes conversational memory — organic preference learning, evidence-backed recall, and transparent 'what do you know about me?' responses. Document ingestion goes through memory-ingest; the dispatched specialist produces typed-section JSON in-turn from the loaded ontology. Two modes: `document` (default) for unstructured PDF/web content → :KnowledgeDocument (keyed on `attachmentId`) + :Section, and `chat` for conversation transcripts → :ConversationArchive (keyed on `conversationIdentity`) + :Section chunks; two parent labels, two writer paths chosen by which identity property is set. Conversation-archive Phase 2 (`conversation-archive-derive-insights`) walks chunks of one named archive and emits per-row claim proposals for operator-gated wiring; `conversation-archive-enrich-rejection` records (or undoes) durable per-row rejections so already-triaged claims do not re-surface on re-runs. Ships four skills: `conversational-memory`, `document-ingest`, `conversation-archive` (source-agnostic transcript ingest for WhatsApp, Telegram, Signal, LinkedIn DMs, Zoom, meeting minutes, iMessage, Slack), and `conversation-archive-enrich` (per-row operator-gated insight derivation over a named archive's chunks)."
 tools:
   - name: memory-search
     publicAllowlist: true
     adminAllowlist: true
-  - name: memory-rank
-    publicAllowlist: false
-    adminAllowlist: false
   - name: memory-write
     publicAllowlist: false
     adminAllowlist: true
@@ -26,9 +23,6 @@ tools:
   - name: memory-ingest-web
     publicAllowlist: false
     adminAllowlist: false
-  - name: memory-classify
-    publicAllowlist: false
-    adminAllowlist: false
   - name: memory-find-candidates
     publicAllowlist: false
     adminAllowlist: true
@@ -146,11 +140,9 @@ Provides read and write access to the Neo4j knowledge graph — search, structur
 
 Tools are available via the `memory` MCP server.
 
-## LLM-Reasoned Ranking
-
-`memory-rank` is a ranking tool built on top of `memory-search`. It retrieves a candidate pool from the graph using the same hybrid vector+BM25 pipeline, then passes the candidates to Claude Haiku along with a natural-language ranking criterion. The response is an ordered list with a short reasoning string per item explaining why each candidate landed where it did.
+## Ranking
 
-Ranking is ephemeral and contextual — nothing is written back to the graph. When the Anthropic API key is unavailable or the model call fails, the tool returns the unranked memory-search results with a visible `[Ranking unavailable: <reason>]` notice so the agent can tell the user that ranking did not run. The ranking criterion is sandboxed as a directive inside the user message; imperative instructions embedded in it are treated as data, not control flow.
+Ranking is in-turn agent work — call `memory-search` for a candidate pool of 15–30 rows (use `limit` to size the pool), then order them yourself against the operator's criterion. The agent has the same context the server-side ranker used to have plus the conversation history the server never saw, so the right place to rank is the calling agent's turn. Task 424 removed the `memory-rank` tool (server-side Haiku rerank against a `criteria` string) — the criterion now lives in your reasoning, not in a separate OAuth round-trip.
 
 ## Search Output Size
 
@@ -192,7 +184,7 @@ Graph hygiene is **agent-directed, case by case** — no autonomous rule engine,
 
 ## Brain-capture diagnostic — `memory-signals-recent`
 
-Read-only window into the extractive graph writes produced under this account. Returns recent `:MENTIONS` edges (`:Message-[:MENTIONS]->Entity`) and `:Idea` nodes interleaved by `observedAt`. Default window is 24 hours; pass `windowHours` (max 720) and `limit` (max 200) to scan a longer arc. Use this when the operator asks "what has the brain captured today?", "show me recent mentions of X", or "what ideas did I leave on the table this week?". Writes are produced by `database-operator`, either inline at admin discretion or via the once-per-operator-prompt background pass (`platform/plugins/admin/hooks/pre-turn-graph-pass.sh`, Task 425 — supersedes the Task 412 Stop-hook variant of the same logic, which itself superseded the original `signal-detector` specialist + throttled hook from Task 303).
+Read-only window into the extractive graph writes produced under this account. Returns recent `:MENTIONS` edges (`:Message-[:MENTIONS]->Entity`) and `:Idea` nodes interleaved by `observedAt`. Default window is 24 hours; pass `windowHours` (max 720) and `limit` (max 200) to scan a longer arc. Use this when the operator asks "what has the brain captured today?", "show me recent mentions of X", or "what ideas did I leave on the table this week?". Writes are produced by `database-operator` per-write briefs admin dispatches — either inline mid-turn, or as part of the once-per-operator-prompt pre-turn graph pass orchestrated by admin (`platform/plugins/admin/hooks/pre-turn-graph-pass.sh`, Tasks 425 + 430 — 430 reshaped the hook so admin walks the turn and dispatches per-write, after the 425 shape was found to self-deny when operator prose pattern-matched as a writer instruction; 425 itself superseded the Task 412 Stop-hook variant, which superseded the original `signal-detector` specialist + throttled hook from Task 303).
 
 ## Conversational Memory
 
@@ -243,11 +235,11 @@ Document ingestion of any kind — PDFs, text, transcripts, web pages, single fi
 
 ### Pipeline
 
-The skill drives a three-tool pipeline:
+The skill drives a two-tool pipeline with the dispatched specialist's in-turn work in between:
 
-1. **`memory-ingest-extract`** — pulls text from PDF/markdown/plain-text and caches it under the `attachmentId`. No chunking — the chunker has moved upstream into LLM-driven section classification.
-2. **`memory-classify`** — calls Claude Haiku with the loaded ontology and the cached text; returns typed sections (`{kind, title, body, properties, anchorEdge, related}`). Every returned `kind` is verified against the live ontology label set; invalid labels become `UNMAPPED` so a hallucination never reaches the writer.
-3. **`memory-ingest`** — writes typed graph nodes (Position, Service, Credential, etc.) anchored to `UserProfile` / `LocalBusiness` / `Person` / `Organization` via natural ontology edges, plus `(KnowledgeDocument)-[:REFERENCES]->(typed)` links. UNMAPPED sections become generic `:Section` nodes hanging off the document via `HAS_SECTION` (legacy fallback) so free-form prose retrieval still works.
+1. **`memory-ingest-extract`** — pulls text from PDF/markdown/plain-text and caches it under the `attachmentId`. No chunking — the chunker has moved upstream into in-turn section classification.
+2. **In-turn classification (specialist's work)** — the dispatched specialist reads the cached text and the loaded ontology, then produces typed-section JSON (`{kind, title, body, properties, anchorEdge, related}`) directly in its turn. Every `kind` must come from the ontology label set the writer enforces — the writer rejects out-of-set kinds, so the specialist verifies before emitting. Task 424 deleted the `memory-classify` server tool that previously ran this step as a separate OAuth round-trip.
+3. **`memory-ingest`** — writes typed graph nodes (Position, Service, Credential, etc.) anchored to `UserProfile` / `LocalBusiness` / `Person` / `Organization` via natural ontology edges, plus `(KnowledgeDocument)-[:REFERENCES]->(typed)` links. `Other` sections become generic `:Section:Other` nodes hanging off the document via `HAS_SECTION` (ontology-growth fallback) so free-form prose retrieval still works.
 
 ### Scope
 

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

@@ -106,15 +106,8 @@ const NEO4J_LIB_PATH = resolve(
   "lib",
   "neo4j.js",
 );
-const LLM_CLASSIFIER_PATH = resolve(
-  platformRoot,
-  "plugins",
-  "memory",
-  "mcp",
-  "dist",
-  "lib",
-  "llm-classifier.js",
-);
+// LLM_CLASSIFIER_PATH removed by Task 424. Task 435 reintroduces per-chunk
+// enrichment as in-turn specialist work.
 const MEMORY_INGEST_PATH = resolve(
   platformRoot,
   "plugins",
@@ -467,7 +460,7 @@ async function main() {
   let sessionize, toTurnText, findDeltaCursor;
   let deriveConversationIdentity, deriveMessageContentHash;
   let verifyParticipantElementIds;
-  let getSession, classifyDocument, memoryIngest;
+  let getSession, memoryIngest;
   try {
     ({ getNormaliser } = await import(NORMALISERS_PATH));
     ({ sessionize } = await import(join(PIPELINE_PATH, "sessionize.js")));
@@ -477,7 +470,6 @@ async function main() {
       await import(join(PIPELINE_PATH, "derive-keys.js")));
     ({ verifyParticipantElementIds } = await import(join(PIPELINE_PATH, "sender-bind.js")));
     ({ getSession } = await import(NEO4J_LIB_PATH));
-    ({ classifyDocument } = await import(LLM_CLASSIFIER_PATH));
     ({ memoryIngest } = await import(MEMORY_INGEST_PATH));
   } catch (err) {
     fail("import", {
@@ -486,6 +478,17 @@ async function main() {
     });
   }
 
+  // Task 424 — per-session Haiku enrichment removed. Every session lands as an
+  // unenriched raw `:Conversation` chunk; topic summaries / keywords / per-chunk
+  // boundaries are reintroduced under Task 435 (specialist produces them
+  // in-turn). Until then, the driver still ingests the archive — operator gets
+  // the conversation in the graph, just without per-chunk enrichment.
+  const classifyDocument = async ({ documentText }) => ({
+    kind: "error",
+    reason: "Task 424 — server-side classifier removed; Task 435 introduces in-turn enrichment.",
+    documentText,
+  });
+
   // Resolve owner AdminUser elementId from (accountId, userId). One Cypher
   // hop replaces the deleted --owner-element-id flag — owner identity is env
   // input, never an out-of-band flag.

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

@@ -6,7 +6,6 @@ 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 { memoryRank } from "./tools/memory-rank.js";
 import { memoryWrite } from "./tools/memory-write.js";
 import { loadSchema } from "./lib/schema-loader.js";
 import { buildLiveSchemaSource, defaultSchemaCypherPath, } from "./lib/live-schema-source.js";
@@ -23,7 +22,6 @@ import { obsidianVaultImport, } from "./tools/obsidian-vault-import.js";
 // `conversationIdentity`; the parent label tracks the dispatch.
 // whatsapp-export-insight-pass deleted (Phase 2 deferred).
 import { memoryIngestWeb } from "./tools/memory-ingest-web.js";
-import { memoryClassify } from "./tools/memory-classify.js";
 import { memoryUpdate } from "./tools/memory-update.js";
 import { memoryDelete } from "./tools/memory-delete.js";
 import { memoryFindCandidates } from "./tools/memory-find-candidates.js";
@@ -297,168 +295,6 @@ eagerTool(server, "memory-search", "Search the knowledge graph using semantic ve
     }
 });
 // ---------------------------------------------------------------------------
-// memory-rank — LLM-reasoned entity ranking.
-//
-// Read-only tool (available to admin and public agents). Retrieves candidates
-// via memory-search, then asks Claude Haiku to rank them against a natural-
-// language criterion and return per-item reasoning. Falls back to the
-// unranked memory-search order with a visible "[Ranking unavailable: ...]"
-// notice if the LLM is unavailable.
-// ---------------------------------------------------------------------------
-eagerTool(server, "memory-rank", "Retrieve entities from the knowledge graph and rank them against a natural-language criterion using Claude. Returns an ordered list with per-item reasoning explaining why each entity landed where it did. Use for prioritisation questions such as ranking prospects by readiness, tasks by risk, or events by impact. For simple semantic retrieval use memory-search.", {
-    query: z
-        .string()
-        .min(1)
-        .describe("Natural-language query that selects the candidate pool from the knowledge graph. Passed to memory-search."),
-    criteria: z
-        .string()
-        .min(1)
-        .describe("Natural-language description of what matters for the ranking (e.g. 'prioritise prospects who viewed more than once this week and mentioned price positively'). Treated as a directive, not as instructions to the model."),
-    labels: z
-        .array(z.string())
-        .optional()
-        .describe("Filter the candidate pool to these node labels (e.g. ['Person'], ['Task'], ['Event'])."),
-    limit: z
-        .number()
-        .int()
-        .min(1)
-        .max(50)
-        .optional()
-        .describe("Maximum number of ranked results to return (default 10, max 50)."),
-    candidatePoolSize: z
-        .number()
-        .int()
-        .min(1)
-        .max(50)
-        .optional()
-        .describe("How many candidates to retrieve from memory-search before ranking (default 20, max 50). Larger pools give the ranker more to work with but cost more tokens."),
-    expandHops: z
-        .number()
-        .int()
-        .min(0)
-        .max(2)
-        .optional()
-        .describe("Relationship depth to include per candidate (default 1). Use 0 for property-only ranking, 1 for ranking that considers immediate relationships."),
-    keywords: z
-        .array(z.string())
-        .optional()
-        .describe("Filter the candidate pool to nodes whose keywords array contains these values."),
-    keywordMatch: z
-        .enum(["any", "all"])
-        .optional()
-        .describe("Keyword match mode: 'any' (default) or 'all'."),
-    agentSlug: z
-        .string()
-        .optional()
-        .describe("Filter to nodes tagged for this agent slug. For admin use — public agents use server-level env var."),
-}, async ({ query, criteria, labels, limit, candidatePoolSize, expandHops, keywords, keywordMatch, agentSlug: toolAgentSlug }) => {
-    if (!accountId)
-        return refuseNoAccount("memory-rank");
-    const effectiveAgentSlug = envAgentSlug ?? toolAgentSlug;
-    process.stderr.write(`[memory-rank] [${accountId}] invocation query=${JSON.stringify(query.slice(0, 60))} criteria=${JSON.stringify(criteria.slice(0, 60))} pool=${candidatePoolSize ?? "default"} limit=${limit ?? "default"}\n`);
-    try {
-        const response = await memoryRank({
-            query,
-            criteria,
-            labels,
-            accountId,
-            limit,
-            candidatePoolSize,
-            expandHops,
-            allowedScopes,
-            keywords,
-            keywordMatch,
-            agentSlug: effectiveAgentSlug,
-            keywordSubscriptions: envKeywordSubscriptions,
-        });
-        // Three distinct empty/near-empty cases with different meanings:
-        //   1. candidatePoolSize === 0 — memory-search found nothing. True empty result.
-        //   2. candidatePoolSize > 0, results.length === 0, no fallback — Haiku
-        //      considered the candidates and said none matched the criterion. The
-        //      agent must be told that candidates existed but were rejected, not
-        //      that nothing was found.
-        //   3. candidatePoolSize > 0, results.length > 0 — normal ranked output
-        //      (or ranked-fallback unranked output when fallbackReason is set).
-        if (response.candidatePoolSize === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "No candidates found for this query.",
-                    },
-                ],
-            };
-        }
-        if (response.results.length === 0 && !response.fallbackReason) {
-            // Haiku ran successfully and returned rankings: []. Candidates existed
-            // but none matched the criterion. Report this honestly so the agent
-            // can relay it to the user instead of claiming nothing was found.
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Considered ${response.candidatePoolSize} candidate${response.candidatePoolSize === 1 ? "" : "s"} but none matched the criterion.`,
-                    },
-                ],
-            };
-        }
-        const headerLines = [];
-        if (response.fallbackReason) {
-            headerLines.push(`[Ranking unavailable: ${response.fallbackReason}] — showing ${response.results.length} candidates in their original memory-search score order.`);
-        }
-        else {
-            headerLines.push(`Ranked ${response.results.length} of ${response.candidatePoolSize} candidates.`);
-            if (response.hallucinated > 0) {
-                headerLines.push(`(${response.hallucinated} ranker response${response.hallucinated === 1 ? "" : "s"} referenced candidates not in the pool and were discarded.)`);
-            }
-        }
-        const body = response.results
-            .map((r) => {
-            const rankLine = r.rank !== undefined ? `#${r.rank} ` : "";
-            const reasoningLine = r.reasoning ? `\n  reasoning: ${r.reasoning}` : "";
-            let text = `${rankLine}[${r.labels.join(", ")}] (id: ${r.nodeId}) (score: ${r.score.toFixed(3)})${reasoningLine}\n`;
-            for (const [k, v] of Object.entries(r.properties)) {
-                text += `  ${k}: ${String(v)}\n`;
-            }
-            if (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;
-        })
-            .join("\n---\n");
-        const output = `${headerLines.join("\n")}\n\n${body}`;
-        return {
-            content: [{ type: "text", text: output }],
-        };
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`[memory-rank] [${accountId}] unhandled error: ${msg}\n`);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Rank failed: ${msg}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-});
-// ---------------------------------------------------------------------------
 // conversation-archive Phase 2: chunk-anchored insight derivation.
 // Read-only tool. Walks the :Section chunks of one named conversation
 // archive (`:ConversationArchive` keyed on `conversationIdentity` — Task
@@ -866,28 +702,12 @@ if (!readOnly) {
             };
         }
     });
-    server.tool("memory-update", "Update properties on an existing node in the knowledge graph. Finds the node by element ID, verifies account ownership, sets the provided properties, and recomputes the embedding. For :Person / :Organization / :Concept / :Project / :LocalBusiness, pass rewriteCompiledTruth=true to recompute the admin compiledTruth summary; when the label is in the public-twin set (:Organization / :Concept / :Project / :LocalBusiness) and the admin pass changes the truth, the public-twin compiledTruthPublic auto-rewrites in the same call. Pair rewriteCompiledTruth=true with operatorHint to feed the rewriter an operator correction from chat for the admin twin — the resulting write is stamped compiledTruthSource='operator', the 7-day cooldown does not block it, and the public-twin auto-fire is skipped. Pair rewriteCompiledTruth=true with publicOperatorHint to do the same for the public twin — the public rewriter is invoked with the hint folded into the public-mode prompt regardless of whether the admin pass changed the truth, the public-cooldown is bypassed, and the write is stamped compiledTruthPublicSource='operator'. Direct writes to compiledTruth / compiledTruthUpdatedAt / compiledTruthSource / compiledTruthPublic / compiledTruthPublicUpdatedAt / compiledTruthPublicSource via the properties bag are refused — the rewriter is the only writer.", {
+    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).", {
         nodeId: z.string().describe("Element ID of the node to update (from memory-search results)"),
         properties: z
             .record(z.string(), z.unknown())
-            .describe("Properties to set or overwrite. Restricted keys (embedding, accountId, createdAt) are ignored. Compiled-truth fields are system-managed and rejected loudly here — use rewriteCompiledTruth (optionally with operatorHint or publicOperatorHint)."),
-        rewriteCompiledTruth: z
-            .boolean()
-            .optional()
-            .describe("When true, run the compiled-truth rewriter against the node's most recent :TimelineEvent rows. Writes the admin compiledTruth, and (for :Organization / :Concept / :Project / :LocalBusiness, when the admin rewrite actually changes the text) also re-runs the rewriter in public mode and writes compiledTruthPublic. No-op admin rewrites skip the public pass. Valid on :Person / :Organization / :Concept / :Project / :LocalBusiness."),
-        forceRewrite: z
-            .boolean()
-            .optional()
-            .describe("Bypass the 7-day cooldown that protects operator-edited compiledTruth and compiledTruthPublic fields from automatic rewriter passes. Set only when the operator explicitly asks for a refresh."),
-        operatorHint: z
-            .string()
-            .optional()
-            .describe("Operator correction for the admin twin, supplied via chat. Only valid with rewriteCompiledTruth=true. Folded into the rewriter prompt with precedence over the timeline; the resulting write is stamped compiledTruthSource='operator', the 7-day cooldown does not block this pass, and the public-twin auto-fire is skipped so admin-side corrections do not leak unreviewed to the public surface. Cap: 1000 characters."),
-        publicOperatorHint: z
-            .string()
-            .optional()
-            .describe("Operator correction for the public twin, supplied via chat. Only valid with rewriteCompiledTruth=true AND a public-twin label (:Organization / :Concept / :Project / :LocalBusiness — :Person has no public twin). Folded into the public-mode rewriter prompt with precedence over the timeline; the public rewriter fires regardless of whether the admin pass changed the truth, the public-cooldown is bypassed, and the write is stamped compiledTruthPublicSource='operator'. Cap: 1000 characters."),
-    }, async ({ nodeId, properties, rewriteCompiledTruth, forceRewrite, operatorHint, publicOperatorHint }) => {
+            .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 {
@@ -900,50 +720,12 @@ if (!readOnly) {
                     session: resolveSessionId(),
                     tool: "memory-update",
                 },
-                rewriteCompiledTruth,
-                forceRewrite,
-                operatorHint,
-                publicOperatorHint,
             });
-            const rewriterLine = (() => {
-                if (!result.rewriter)
-                    return "";
-                if (result.rewriter.kind === "ok") {
-                    const sourceFragment = result.rewriter.source === "operator" ? " (operator-attributed)" : "";
-                    return `\nAdmin compiled-truth rewritten${sourceFragment}: ${result.rewriter.charsBefore} → ${result.rewriter.charsAfter} chars.`;
-                }
-                if (result.rewriter.kind === "refused") {
-                    return result.rewriter.reason === "operator-edit-cooldown"
-                        ? `\nAdmin rewriter refused: operator-edit cooldown (${result.rewriter.daysRemaining} day(s) remaining; pass forceRewrite=true to override).`
-                        : `\nAdmin rewriter refused: no :TimelineEvent rows linked to this node.`;
-                }
-                if (result.rewriter.kind === "too-long") {
-                    return `\nAdmin rewriter output exceeded ${result.rewriter.attemptedLen} chars after one retry; compiledTruth unchanged.`;
-                }
-                return `\nAdmin rewriter LLM call failed (cause=${result.rewriter.cause}); compiledTruth unchanged.`;
-            })();
-            const publicRewriterLine = (() => {
-                if (!result.publicRewriter)
-                    return "";
-                if (result.publicRewriter.kind === "ok") {
-                    const sourceFragment = result.publicRewriter.source === "operator" ? " (operator-attributed)" : "";
-                    return `\nPublic compiled-truth rewritten${sourceFragment}: ${result.publicRewriter.charsBefore} → ${result.publicRewriter.charsAfter} chars.`;
-                }
-                if (result.publicRewriter.kind === "refused") {
-                    return result.publicRewriter.reason === "operator-edit-cooldown"
-                        ? `\nPublic rewriter refused: operator-edit cooldown (${result.publicRewriter.daysRemaining} day(s) remaining; pass forceRewrite=true to override).`
-                        : `\nPublic rewriter refused: no :TimelineEvent rows linked to this node.`;
-                }
-                if (result.publicRewriter.kind === "too-long") {
-                    return `\nPublic rewriter output exceeded ${result.publicRewriter.attemptedLen} chars after one retry; compiledTruthPublic unchanged.`;
-                }
-                return `\nPublic rewriter LLM call failed (cause=${result.publicRewriter.cause}); compiledTruthPublic unchanged.`;
-            })();
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Node updated: [${result.labels.join(", ")}] (ID: ${result.nodeId})${rewriterLine}${publicRewriterLine}`,
+                        text: `Node updated: [${result.labels.join(", ")}] (ID: ${result.nodeId})`,
                     },
                 ],
             };
@@ -1075,11 +857,11 @@ if (!readOnly) {
             };
         }
     });
-    server.tool("memory-ingest-extract", "Extract text from an uploaded file and cache it server-side for memory-classify and memory-ingest. " +
+    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. " +
-        "Chunking has moved upstream into memory-classify (LLM-driven section classification) — this tool no longer chunks.", {
+        "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"),
@@ -1106,45 +888,8 @@ if (!readOnly) {
             };
         }
     });
-    server.tool("memory-classify", "Classify an unstructured document into typed sections via Claude Haiku. " +
-        "Reads the cached text written by memory-ingest-extract (same attachmentId), runs the classifier against " +
-        "the live ontology label set, and returns a JSON structure ready for memory-ingest. Every returned `kind` is " +
-        "verified server-side against the ontology — invalid labels become `UNMAPPED` so the writer falls back to " +
-        "generic Section nodes with a logged ontology gap. When Haiku is unavailable, returns `{kind: \"fallback\"}` " +
-        "with a reason — the skill should treat the whole document as one UNMAPPED Section.", {
-        attachmentId: z.string().describe("UUID of the file attachment — must match a prior memory-ingest-extract call"),
-        anchorDescription: z.string().describe("Short human sentence describing the document subject the classifier should anchor sections to. " +
-            "Examples: 'subject = UserProfile (the account owner)'; 'subject = LocalBusiness (the operator's business)'; " +
-            "'subject = Person {name: \"Jane Smith\"} (a third party)'."),
-    }, async ({ attachmentId, anchorDescription }) => {
-        if (!accountId)
-            return refuseNoAccount("memory-classify");
-        try {
-            const result = await memoryClassify({
-                accountId,
-                attachmentId,
-                anchorDescription,
-                liveSchemaSource: liveSchemaRuntime.source,
-            });
-            return {
-                content: [{
-                        type: "text",
-                        text: JSON.stringify(result),
-                    }],
-            };
-        }
-        catch (err) {
-            return {
-                content: [{
-                        type: "text",
-                        text: `memory-classify failed: ${err instanceof Error ? err.message : String(err)}`,
-                    }],
-                isError: true,
-            };
-        }
-    });
     server.tool("memory-ingest", "Write a classified document into the graph as typed nodes anchored to the document subject. " +
-        "Requires prior calls to memory-ingest-extract (text cache) and memory-classify (typed structure). " +
+        "Requires a prior memory-ingest-extract call for the text cache; the typed-section JSON in the `sections` argument is produced by the dispatched specialist in-turn from the loaded ontology. " +
         "Each section becomes either a typed graph node (Position, Service, Credential, etc.) anchored to the named " +
         "subject via the natural ontology edge plus a (KnowledgeDocument)-[:REFERENCES]->(typed) link, or — for " +
         "UNMAPPED sections — a generic :Section node hanging off the document via HAS_SECTION (legacy fallback). " +
@@ -1160,8 +905,8 @@ if (!readOnly) {
         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().describe("Server-reconstructed body text: memory-classify slices documentText.slice(sourceStart, sourceEnd) and stamps it here, so this stays the writer's contract."),
-            summary: z.string().describe("1-3 sentence summary of the section — already truncated to 500 chars by memory-classify; stored as :Section.summary."),
+            body: z.string().describe("Body text for this section — the specialist slices documentText.slice(sourceStart, sourceEnd) and stamps it here. The writer treats it as the section's content."),
+            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()),
@@ -1181,7 +926,7 @@ if (!readOnly) {
                 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 as returned by memory-classify, in reading order. The writer chains them via :NEXT in this order."),
+        })).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"]),
@@ -1392,8 +1137,7 @@ if (!readOnly) {
     // source.
     server.tool("memory-ingest-web", "Adapter for web-content ingestion. Accepts a URL and its pre-fetched readable content " +
         "(the agent calls WebFetch first, then passes the text here), writes content to a temp file, and delegates " +
-        "to memory-ingest-extract — caching the text under a freshly-generated attachmentId. The skill then drives " +
-        "memory-classify and memory-ingest using that attachmentId, exactly as for a file upload. " +
+        "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. " +
         "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)"),
@@ -1651,11 +1395,11 @@ if (!readOnly) {
             let text = `Edited: ${result.filename} (${result.oldSizeBytes} → ${result.newSizeBytes} bytes)`;
             if (result.cachePopulated) {
                 text += `\nExtract cache populated: ${result.extractTextLength} chars.`;
-                text += `\nCall memory-classify and memory-ingest to re-sync the knowledge graph.`;
+                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 memory-classify, then memory-ingest.`;
+                text += `\nCall memory-ingest-extract manually, then produce typed-section JSON in-turn and call memory-ingest.`;
             }
             return { content: [{ type: "text", text }] };
         }