@rubytech/create-maxy-code 0.1.144 → 0.1.146

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

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

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

@@ -1,6 +1,6 @@
 ---
 name: memory
-description: "Graph memory plugin. Provides memory-search (with optional `fields` projection for known-shape lookups), memory-rank, memory-write, and memory-update tools for reading from, writing to, and updating the Neo4j knowledge graph. Includes conversational memory — organic preference learning, evidence-backed recall, and transparent 'what do you know about me?' responses. Document ingestion (memory-classify + memory-ingest) supports two modes: `document` (default) for unstructured PDF/web content → :KnowledgeDocument (keyed on `attachmentId`) + :Section, and `chat` for conversation transcripts → :KnowledgeDocument (keyed on `conversationIdentity`) + :Section chunks; one parent label, two writer paths chosen by which identity property is set. Conversation-archive Phase 2 (`conversation-archive-derive-insights`) walks chunks of one named archive and emits per-row claim proposals for operator-gated wiring; `conversation-archive-enrich-rejection` records (or undoes) durable per-row rejections so already-triaged claims do not re-surface on re-runs. Ships four skills: `conversational-memory`, `document-ingest`, `conversation-archive` (source-agnostic transcript ingest for WhatsApp, Telegram, Signal, LinkedIn DMs, Zoom, meeting minutes, iMessage, Slack), and `conversation-archive-enrich` (per-row operator-gated insight derivation over a named archive's chunks)."
+description: "Graph memory plugin. Provides memory-search (with optional `fields` projection for known-shape lookups), memory-rank, memory-write, memory-update, and the :Report surface (memory-report-write / memory-report-read-latest / memory-report-list) for reading from, writing to, and updating the Neo4j knowledge graph. Includes conversational memory — organic preference learning, evidence-backed recall, and transparent 'what do you know about me?' responses. Document ingestion (memory-classify + memory-ingest) supports two modes: `document` (default) for unstructured PDF/web content → :KnowledgeDocument (keyed on `attachmentId`) + :Section, and `chat` for conversation transcripts → :KnowledgeDocument (keyed on `conversationIdentity`) + :Section chunks; one parent label, two writer paths chosen by which identity property is set. Conversation-archive Phase 2 (`conversation-archive-derive-insights`) walks chunks of one named archive and emits per-row claim proposals for operator-gated wiring; `conversation-archive-enrich-rejection` records (or undoes) durable per-row rejections so already-triaged claims do not re-surface on re-runs. Ships four skills: `conversational-memory`, `document-ingest`, `conversation-archive` (source-agnostic transcript ingest for WhatsApp, Telegram, Signal, LinkedIn DMs, Zoom, meeting minutes, iMessage, Slack), and `conversation-archive-enrich` (per-row operator-gated insight derivation over a named archive's chunks)."
 tools:
   - name: memory-search
     publicAllowlist: true
@@ -65,6 +65,18 @@ tools:
   - name: conversation-archive-enrich-rejection
     publicAllowlist: false
     adminAllowlist: false
+  - name: memory-report-write
+    publicAllowlist: false
+    adminAllowlist: true
+  - name: memory-report-read-latest
+    publicAllowlist: false
+    adminAllowlist: true
+  - name: memory-report-list
+    publicAllowlist: false
+    adminAllowlist: true
+  - name: memory-compiled-truth-history
+    publicAllowlist: false
+    adminAllowlist: true
   - name: conversation-list
     publicAllowlist: false
     adminAllowlist: true
@@ -95,6 +107,12 @@ tools:
   - name: conversation-memory-expunge
     publicAllowlist: false
     adminAllowlist: true
+  - name: memory-dream-run
+    publicAllowlist: false
+    adminAllowlist: true
+  - name: memory-review-queue
+    publicAllowlist: false
+    adminAllowlist: true
 hidden:
   - session-compact
   - session-compact-status
@@ -168,9 +186,13 @@ Graph hygiene is **agent-directed, case by case** — no autonomous rule engine,
 
 **Why soft-delete.** On 2026-04-20 an autonomous orphan-delete rule wiped 19 nodes in one `graph-prune-run` call; properties were unrecoverable (Neo4j Community has no PITR, no APOC). The cron, the `graph-prune-run` tool, and the rule engine have been removed. An earlier fix added the `:Trashed` label primitive so every soft-delete caller (`memory-delete`, `contact-delete`, the admin `/graph` page's trash button) runs the same shared `trashNode` helper — relationships preserved, unique keys snapshotted into `_trashedKeys`, audit lines `[trash:marked] by=<surface>` for cross-cut provenance.
 
-## Signal-detector diagnostic — `memory-signals-recent`
+## Dream-cycle maintenance — `memory-dream-run` / `memory-review-queue`
+
+`memory-dream-run` is the operator-initiated graph-hygiene sweep — four phases (orphan detection on `:Person`/`:Organization`/`:Concept`/`:Project`; stale compiled-truth scan on `compiledTruthUpdatedAt`; mark edges to `:Trashed` targets with `staleTarget: true`; LLM-bounded citation audit on `:TimelineEvent`). Each run writes a `:Report` (via `memory-report-write` from Task 332) summarising counts; per-phase log lines `[dream-cycle:phase-<n>]` join on the run id. Failure of any phase logs `[dream-cycle:phase-<n>:error]` and continues — subsequent phases still run. Pass `phases: [4]` to run only the citation audit (e.g. after a bulk ingest); `maxEventsPerRun` defaults to 200 to cap LLM cost, with a resume cursor stored as `:Report.lastEventCursor` so subsequent runs continue from the last processed event. `memory-review-queue` is the read-only surface for `:OrphanCandidate` and `:CitationProposal` queues — counts plus a small sample per queue. Phase 5 (backlinks) and phase 6 (tag consistency) are deferred to follow-up tasks. Task 327; absorbs Task 330.
+
+## Brain-capture diagnostic — `memory-signals-recent`
 
-Read-only window into the writes the `signal-detector` specialist has 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?". The signal-detector specialist itself is dispatched only by the admin-agent Stop hook at `platform/plugins/admin/hooks/signal-detector-stop.sh` — never by operator intent and never via `<specialist-domains>` routing. Task 303.
+Read-only window into the extractive graph writes produced under this account. Returns recent `:MENTIONS` edges (`:Message-[:MENTIONS]->Entity`) and `:Idea` nodes interleaved by `observedAt`. Default window is 24 hours; pass `windowHours` (max 720) and `limit` (max 200) to scan a longer arc. Use this when the operator asks "what has the brain captured today?", "show me recent mentions of X", or "what ideas did I leave on the table this week?". Writes are produced by `database-operator`, either inline at admin discretion or via the once-per-turn background pass (`platform/plugins/admin/hooks/post-turn-graph-pass.sh`, Task 412 — supersedes the original `signal-detector` specialist + throttled hook from Task 303).
 
 ## Conversational Memory
 

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

@@ -46,6 +46,12 @@ import { conversationArchiveEnrichRejection } from "./tools/conversation-archive
 import { fetchImageAsContent } from "./tools/image-fetch.js";
 import { memoryTypedEdgePass } from "./tools/memory-typed-edge-pass.js";
 import { sessionRetrospectiveSkipRate } from "./tools/session-retrospective-skip-rate.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";
@@ -581,6 +587,165 @@ server.tool("conversation-archive-enrich-rejection", "Record or undo a per-row r
     }
 });
 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
@@ -643,20 +808,82 @@ 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, pass rewriteCompiledTruth=true to recompute the compiled-truth summary from the most recent :TimelineEvent rows; direct writes to compiledTruth / compiledTruthUpdatedAt / compiledTruthSource are refused.", {
+    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.CONVERSATION_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", "Update properties on an existing node in the knowledge graph. Finds the node by element ID, verifies account ownership, sets the provided properties, and recomputes the embedding. For :Person / :Organization / :Concept / :Project / :LocalBusiness, pass rewriteCompiledTruth=true to recompute the admin compiledTruth summary; when the label is in the public-twin set (:Organization / :Concept / :Project / :LocalBusiness) and the admin pass changes the truth, the public-twin compiledTruthPublic auto-rewrites in the same call. Pass compiledTruthPublic to override the public twin directly via chat. Direct writes to compiledTruth / compiledTruthUpdatedAt / compiledTruthSource / compiledTruthPublic / compiledTruthPublicUpdatedAt / compiledTruthPublicSource via the properties bag are refused — use the dedicated arguments.", {
         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. compiledTruth / compiledTruthUpdatedAt / compiledTruthSource are system-managed and rejected loudly — use rewriteCompiledTruth instead."),
+            .describe("Properties to set or overwrite. Restricted keys (embedding, accountId, createdAt) are ignored. Compiled-truth fields are system-managed and rejected loudly here — use rewriteCompiledTruth or the compiledTruthPublic argument."),
         rewriteCompiledTruth: z
             .boolean()
             .optional()
-            .describe("When true, run the compiled-truth rewriter against the node's most recent :TimelineEvent rows and set the result on compiledTruth. Only valid on :Person / :Organization / :Concept."),
+            .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 an operator-edited compiledTruth from automatic rewriter passes. Set only when the operator explicitly asks for a refresh."),
-    }, async ({ nodeId, properties, rewriteCompiledTruth, forceRewrite }) => {
+            .describe("Bypass the 7-day cooldown that protects operator-edited compiledTruth and compiledTruthPublic fields from automatic rewriter passes. Set only when the operator explicitly asks for a refresh."),
+        compiledTruthPublic: z
+            .string()
+            .optional()
+            .describe("Operator override for the public-facing compiled-truth twin. Writes the supplied string verbatim, stamps source='operator', and resets the public-twin cooldown. Length cap: 2000 characters. Only valid on :Organization / :Concept / :Project / :LocalBusiness (:Person has no public twin)."),
+    }, async ({ nodeId, properties, rewriteCompiledTruth, forceRewrite, compiledTruthPublic }) => {
         if (!accountId)
             return refuseNoAccount("memory-update");
         try {
@@ -671,28 +898,55 @@ if (!readOnly) {
                 },
                 rewriteCompiledTruth,
                 forceRewrite,
+                compiledTruthPublic,
             });
             const rewriterLine = (() => {
                 if (!result.rewriter)
                     return "";
                 if (result.rewriter.kind === "ok") {
-                    return `\nCompiled-truth rewritten: ${result.rewriter.charsBefore} → ${result.rewriter.charsAfter} chars.`;
+                    return `\nAdmin compiled-truth rewritten: ${result.rewriter.charsBefore} → ${result.rewriter.charsAfter} chars.`;
                 }
                 if (result.rewriter.kind === "refused") {
                     return result.rewriter.reason === "operator-edit-cooldown"
-                        ? `\nRewriter refused: operator-edit cooldown (${result.rewriter.daysRemaining} day(s) remaining; pass forceRewrite=true to override).`
-                        : `\nRewriter refused: no :TimelineEvent rows linked to this node.`;
+                        ? `\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 `\nRewriter output exceeded ${result.rewriter.attemptedLen} chars after one retry; compiledTruth unchanged.`;
+                    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") {
+                    return `\nPublic compiled-truth rewritten: ${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.`;
+            })();
+            const overrideLine = (() => {
+                if (!result.publicOverride)
+                    return "";
+                if (result.publicOverride.kind === "applied") {
+                    return `\ncompiledTruthPublic overridden by operator: ${result.publicOverride.chars} chars.`;
                 }
-                return `\nRewriter LLM call failed (cause=${result.rewriter.cause}); compiledTruth unchanged.`;
+                return result.publicOverride.reason === "wrong-label"
+                    ? `\ncompiledTruthPublic override refused: label is not in the public-twin set (:Organization / :Concept / :Project / :LocalBusiness).`
+                    : `\ncompiledTruthPublic override refused: exceeds 2000 character cap.`;
             })();
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Node updated: [${result.labels.join(", ")}] (ID: ${result.nodeId})${rewriterLine}`,
+                        text: `Node updated: [${result.labels.join(", ")}] (ID: ${result.nodeId})${rewriterLine}${publicRewriterLine}${overrideLine}`,
                     },
                 ],
             };
@@ -2152,6 +2406,50 @@ server.tool("session-retrospective-skip-rate", "Return the ratio of recent sessi
         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 five phases " +
+    "(orphan detection, stale compiled-truth, edges to :Trashed targets, citation audit on :TimelineEvent, " +
+    "prune compiled-truth revisions to newest 20 per entity). " +
+    "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), or phases=[5] for revision prune 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(5)).optional().describe("Subset of phases to run. Default [1,2,3,4,5]. 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();