@rubytech/create-realagent-code 0.1.144 → 0.1.147

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

@@ -297,6 +297,22 @@ This makes the failure visible to the agent, which can relay it to the user. Deg
 
 ---
 
+## Reports — durable workflow output (Task 332)
+
+The `:Report` label is the platform's durable shape for workflow output the operator may want back later — daily briefings, dream cycle runs, ad-hoc analyses. Three MCP tools own the surface, all on the memory plugin:
+
+- `memory-report-write` — append-only writer. Validates body ≤ 10,000 chars, embeds title+body, and CREATEs a `:Report` node. Idempotent on `(accountId, title, occurredAt-within-same-minute)` — a second call with the same title in the same minute returns the existing node instead of duplicating. Parented to the active `:Conversation` via `:PRODUCED` when `CONVERSATION_NODE_ID` is set (the chat-driven default); falls back to the account's `:AdminUser` so the graph-hierarchy doctrine holds even outside a conversation.
+- `memory-report-read-latest` — fetches the newest `:Report` (default `limit=1`) tagged with a given keyword. The expected route for any operator phrasing of "latest X", "last night's X", "show me X report".
+- `memory-report-list` — metadata-only paginated listing (newest first), with optional `keyword` and `sourceWorkflow` filters. Use to scan the catalogue without paying for full bodies.
+
+Every operation emits one log line: `[reports] op=<write|read-latest|list> reportId=<short> keywords=<csv> ms=<n>` (with `idempotent=1` on a write that resolved to an existing node, `hits=<n>` on reads, `total=<n>` on list).
+
+Routing is not classifier-side. The admin agent's `IDENTITY.md` carries the rule under **Recalling reports**: "latest <X>" / "last night's <X>" / "show me <X> report" → first tool call is `memory-report-read-latest`. The intent classifier (Task 304's `retrievalClass`) already differentiates temporal vs entity vs event reads; reports route off the literal phrase, not a new class.
+
+The first caller is the `briefing` skill (`platform/plugins/scheduling/skills/briefing/SKILL.md`), which persists each run as a `:Report` with `title: "Daily briefing <YYYY-MM-DD>"`, `keywords: ["daily-briefing", "<YYYY-MM-DD>"]`, `sourceWorkflow: "daily-briefing"`. Dream-cycle (Task 327) and ad-hoc analyses are expected to follow the same pattern.
+
+---
+
 ## Graph Expansion
 
 After the top results are selected (by combined score or by LLM ranking), each result node is expanded by traversing its immediate relationships.

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

@@ -116,6 +116,16 @@ Every node also carries a provenance stamp — which agent wrote it, in which se
 
 **Two write surfaces, one substrate.** General agents write through schema-aware helpers — {{productName}} can record a new contact, a new commitment, a new preference without ever typing a database query, and the helper enforces the connection-and-provenance rule above structurally. The graph-steward role (the specialist {{productName}} dispatches when you ask for graph hygiene — "merge those two duplicate contacts," "wire those four tasks to the meeting," "rename the legacy label across the graph") additionally has a raw Cypher write tool for the multi-step operations the helpers cannot express. The steward role internalises the same connection-and-provenance discipline in its prompt; a post-write audit emits a warning on every breach so the same rules apply to both surfaces. Both paths feed the same hourly orphan trend and the same forensic provenance fields — read-side, you cannot tell the two apart, and that is the point.
 
+## Public-facing summaries for customer-readable subjects
+
+Some entities in your graph are knowable by people outside your team — companies you work with, projects you've delivered, the business itself. For those entities ({{productName}} treats `:Organization`, `:Concept`, `:Project`, and `:LocalBusiness` this way), {{productName}} maintains two summaries: a private one only you and your specialist agents see, and a customer-facing public one your public agents are allowed to surface.
+
+Whenever {{productName}} updates the private summary on one of these entities, it automatically rewrites the public summary in the same step using a separate prompt that strips operator-voice ("needs follow-up", "action: chase next week"), internal sentiment, and anything that reads like a note-to-self. The two summaries stay in lockstep without you doing anything.
+
+If you want to write the public summary yourself — for instance, because the auto-generated version misses something you want customers to see — just tell {{productName}} the wording you want for the public summary on that entity, and {{productName}} will write it directly. It stays locked in for seven days; after that, the next automatic refresh can take over again, unless you re-pin it.
+
+People entries (`:Person`) are deliberately excluded from this dual-summary system. Notes about contacts are private by definition and never get a public-facing form.
+
 ## Privacy
 
 All memory is stored on your local Raspberry Pi. The Neo4j database never leaves your network. {{productName}} does not sync memory to any cloud service or third party.

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

@@ -54,7 +54,7 @@ Roles are installed during setup and listed when {{productName}} introduces itse
 
 {{productName}} maintains a graph database (Neo4j) of everything you've told it. People, conversations, preferences, and context are stored as connected nodes. When you ask {{productName}} something, it searches this graph to retrieve relevant context before responding.
 
-**The recording loop.** A background recorder watches every completed admin-agent turn. Once your turn finishes and the reply is on screen, a Stop hook fires the `database-operator` specialist as a single-shot headless Claude Code session: the filtered transcript is written to the recorder's stdin and stdin is closed, so claude processes one turn, writes through the wrapped graph writers, and exits. The row archives the moment claude exits — no long-lived hidden PTY. The admin agent itself does not write to the graph. The recorder runs on a cheap fast model so the recording adds nothing to your perceived latency, and its session never appears in the sidebar or anywhere on the operator UI. To disable it for an account, remove the `Stop` hook entry from that account's `~/.<brand>/.claude/settings.json`; there is no toggle.
+**The recording loop.** Once your turn finishes and the reply is on screen, a Stop hook (`post-turn-graph-pass.sh`) fires the `database-operator` specialist as a background dispatch. The dispatch carries the full conversation as `[role: text]` pairs plus the list of every node already written under this conversation, fetched via `GET /api/admin/post-turn-context`. The specialist decides what new graph rows the conversation supports — mentions of named entities, ideas, learnings, contacts, tasks, anything the schema admits — and writes them. Duplicate writes between this background pass and any inline write the admin agent dispatched mid-turn are accepted and cleaned up by the dream-cycle / hygiene sweeps. There is no throttle and no idle gate: one dispatch per `end_turn`. The admin agent can also dispatch `database-operator` inline at its own discretion when a write must complete before the assistant response ends. To disable the background pass for an account, remove the `post-turn-graph-pass.sh` Stop-hook entry from that account's `~/.<brand>/.claude/settings.json`; there is no toggle.
 
 The memory graph is stored on your Pi. It never leaves your network.
 

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();