@rubytech/create-realagent 1.0.826 → 1.0.829

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

@@ -13,10 +13,9 @@ import { memoryReindex } from "./tools/memory-reindex.js";
 import { memoryIngestExtract } from "./tools/memory-ingest-extract.js";
 import { memoryIngest } from "./tools/memory-ingest.js";
 import { memoryArchiveWrite } from "./tools/memory-archive-write.js";
-import { whatsappExportParse } from "./tools/whatsapp-export-parse.js";
-import { whatsappExportInsightWrite } from "./tools/whatsapp-export-insight-write.js";
-import { whatsappExportPreview } from "./tools/whatsapp-export-preview.js";
-import { whatsappExportInsightPass } from "./tools/whatsapp-export-insight-pass.js";
+// Task 894: WhatsApp `_chat.txt` ingestion flows through the unified
+// document-ingest pipeline (memory-classify mode='chat' + memory-ingest
+// parentLabel='ConversationArchive'); no WhatsApp-specific MCP tools remain.
 import { memoryIngestWeb } from "./tools/memory-ingest-web.js";
 import { memoryClassify } from "./tools/memory-classify.js";
 import { memoryUpdate } from "./tools/memory-update.js";
@@ -779,50 +778,29 @@ if (!readOnly) {
             };
         }
     });
-    server.tool("memory-archive-write", "Bulk-archive write surface (Task 744; Task 804). Writes a flat dataset (typed entities + natural edges) into the graph " +
+    server.tool("memory-archive-write", "Bulk-archive write surface (Task 744). Writes a flat dataset (typed entities + natural edges) into the graph " +
         "in 500-row UNWIND batches. The Cypher body is fixed server-side per `archiveType`; the agent supplies parsed " +
-        "rows + the discriminant, never raw Cypher. Use ONLY for first-class entity exports (LinkedIn Connections, " +
-        "WhatsApp `_chat.txt` exports, future CRM-type seeds). Use memory-ingest for narrative documents " +
-        "(KnowledgeDocument + Section + NEXT) and memory-write for single-node operator-driven writes. " +
-        "Currently supported archiveType values: `linkedin-connections`, `whatsapp-export`. " +
-        "When archiveType='whatsapp-export', the `conversation` block and `participantNodeIds` array are required; " +
-        "otherwise they are ignored.", {
+        "rows + the discriminant, never raw Cypher. Use ONLY for flat first-class entity exports (LinkedIn Connections, " +
+        "future CRM-type seeds). Use memory-ingest for narrative content — including WhatsApp `_chat.txt` archives, " +
+        "which are document-shaped narrative and flow through document-ingest with `parentLabel='ConversationArchive'` " +
+        "(the unified-ingest pipeline). Use memory-write for single-node operator-driven writes. " +
+        "Currently supported archiveType values: `linkedin-connections`.", {
         archiveType: z
-            .enum(["linkedin-connections", "whatsapp-export"])
+            .enum(["linkedin-connections"])
             .describe("Discriminant naming the per-source schema and Cypher body the server runs. Add a new value here only when the corresponding handler is added in memory-archive-write.ts."),
         ownerNodeId: z
             .string()
             .min(1)
-            .describe("elementId of the archive owner — :AdminUser for an operator's own archive, or :Person for an external-archive owner. Confirmed during the skill's owner-confirmation flow before this tool is invoked. For `whatsapp-export`, this is the operator who exported the chat (metadata for provenance, not a row-level subject)."),
+            .describe("elementId of the archive owner — :AdminUser for an operator's own archive, or :Person for an external-archive owner. Confirmed during the skill's owner-confirmation flow before this tool is invoked."),
         rows: z
             .array(z.record(z.string(), z.unknown()))
             .min(1)
-            .describe("Parsed rows. The skill's selective-ingest gate runs BEFORE this tool — large blanket archives get filtered (Company / Position / Connected On range for linkedin-connections; date / sender / keyword for whatsapp-export) before the write call."),
+            .describe("Parsed rows. The skill's selective-ingest gate runs BEFORE this tool — large blanket archives get filtered (e.g. Company / Position / Connected On range for linkedin-connections) before the write call."),
         sessionId: z
             .string()
             .optional()
             .describe("Skill-run UUID for provenance stamping. Falls back to SESSION_ID env var when absent."),
-        conversation: z
-            .object({
-            conversationId: z.string().min(1),
-            archiveSourceFile: z.string().min(1),
-            firstMessageAt: z.string().min(1),
-            lastMessageAt: z.string().min(1),
-            participantCount: z.number().int().nonnegative(),
-            messageCount: z.number().int().nonnegative(),
-        })
-            .optional()
-            .describe("Required for archiveType='whatsapp-export'. One archive-write call writes exactly one Conversation; every row's conversationId must match this block's conversationId or the write is refused."),
-        participantNodeIds: z
-            .array(z.string().min(1))
-            .optional()
-            .describe("Required for archiveType='whatsapp-export'. Array of elementIds (:AdminUser or :Person) covering every distinct sender in `rows`. Server-side `verifyParticipants` rejects unresolved or cross-account ids before any write."),
-        archiveFilePath: z
-            .string()
-            .min(1)
-            .optional()
-            .describe("Required for archiveType='whatsapp-export' (Task 805). Operator-supplied path to the source `_chat.txt`. The server re-computes sha256 of the file bytes and asserts it matches `conversation.archiveSourceFile`. Mismatch is a hard reject before any Cypher runs — closes the silent-substitution window where an agent could pair rows[] for one file with a stale conversation block for another. Pass the same path you supplied to `whatsapp-export-parse`."),
-    }, async ({ archiveType, ownerNodeId, rows, sessionId: sessionIdOverride, conversation, participantNodeIds, archiveFilePath }) => {
+    }, async ({ archiveType, ownerNodeId, rows, sessionId: sessionIdOverride }) => {
         try {
             const result = await memoryArchiveWrite({
                 archiveType,
@@ -830,9 +808,6 @@ if (!readOnly) {
                 accountId,
                 rows: rows,
                 sessionId: resolveSessionId(sessionIdOverride),
-                conversation,
-                participantNodeIds,
-                archiveFilePath,
             });
             return {
                 content: [{
@@ -851,214 +826,6 @@ if (!readOnly) {
             };
         }
     });
-    server.tool("whatsapp-export-parse", "Deterministic WhatsApp `_chat.txt` parser (Task 805). Reads the file, computes sha256 over the raw bytes, " +
-        "decodes UTF-8 (LOUD-FAIL on encoding error), and walks the line grammar — timestamp prefix, sender/body split, " +
-        "multi-line body accumulation, system-message and media-only skip patterns. Returns " +
-        "`{conversationId, archiveSourceFile, parsedLines[], counters}`. The skill consumes the result and passes the " +
-        "same `archiveSourceFile` and `archiveFilePath` to `memory-archive-write`, where the server re-computes the " +
-        "hash and asserts the parser ran on the same file. The agent never tokenises lines itself — this tool replaces " +
-        "the prose grammar in `references/export-parse.md` with deterministic code so silent line-drops cannot occur.", {
-        filePath: z
-            .string()
-            .min(1)
-            .describe("Absolute path to the `_chat.txt` file (typically dropped into chat by the operator and resolved against the attachment store)."),
-        timezone: z
-            .string()
-            .min(1)
-            .describe("IANA timezone the operator confirmed (e.g. 'Europe/London', 'America/New_York', 'UTC'). Each parsed timestamp is emitted as ISO 8601 with the offset that this zone holds for the wall-clock instant — DST is handled correctly."),
-        dateFormat: z
-            .enum(["DD/MM/YY", "MM/DD/YY", "DD/MM/YYYY", "MM/DD/YYYY"])
-            .optional()
-            .describe("Date ordering and year shape. Omit for auto-detect (Task 845): the parser probes the first matched line as DD/MM and locks that ordering if range-valid; otherwise locks MM/DD. Year shape is independent — both 2-digit (legacy) and 4-digit (modern) years are accepted within the same file. Pass an explicit value only when the operator confirms a US-locale export or when auto-detect would mis-lock on a manually concatenated multi-locale archive."),
-    }, async ({ filePath, timezone, dateFormat }) => {
-        try {
-            const result = await whatsappExportParse({
-                filePath,
-                accountId,
-                timezone,
-                dateFormat,
-            });
-            return {
-                content: [{
-                        type: "text",
-                        text: JSON.stringify(result),
-                    }],
-            };
-        }
-        catch (err) {
-            return {
-                content: [{
-                        type: "text",
-                        text: `whatsapp-export-parse failed: ${err instanceof Error ? err.message : String(err)}`,
-                    }],
-                isError: true,
-            };
-        }
-    });
-    server.tool("whatsapp-export-insight-write", "Server-side gated insight-edge writer for WhatsApp imports (Task 805). Writes `:MENTIONS` edges from " +
-        "`:Message` to existing `:Person`/`:AdminUser` nodes, and `:RELATED_TO` edges between two existing distinct " +
-        "Persons. The server re-runs `memory-search` for the named entity and asserts at least one of the operator-" +
-        "supplied `candidateElementIds` matches a live result; rejects single-first-name names without a disambiguator " +
-        "flag; requires `operatorConfirmed: true` for `:RELATED_TO` writes. The agent cannot bypass these gates — they " +
-        "live in code, not in the skill markdown that prior versions of the insight pass relied on.", {
-        kind: z
-            .enum(["MENTIONS", "RELATED_TO"])
-            .describe("Edge type. MENTIONS connects a :Message to a Person/AdminUser referenced in the body. RELATED_TO connects two distinct Persons whose relationship the conversation evidences."),
-        conversationId: z
-            .string()
-            .min(1)
-            .describe("conversationId of the originating WhatsApp conversation (audit context)."),
-        messageId: z
-            .string()
-            .optional()
-            .describe("messageId of the source message — required for kind='MENTIONS', omitted for kind='RELATED_TO'."),
-        fromNodeId: z
-            .string()
-            .min(1)
-            .describe("elementId of the edge tail. For MENTIONS: the :Message. For RELATED_TO: the first :Person/:AdminUser."),
-        toNodeId: z
-            .string()
-            .min(1)
-            .describe("elementId of the edge head. For MENTIONS: the :Person/:AdminUser referenced. For RELATED_TO: the second :Person/:AdminUser."),
-        name: z
-            .string()
-            .min(1)
-            .describe("The display name as it appeared in the chat (e.g. 'Sarah', 'Sarah Chen'). Used to re-run memory-search server-side for the gate."),
-        candidateElementIds: z
-            .array(z.string().min(1))
-            .min(1)
-            .describe("Element IDs the agent's prior memory-search returned. The server re-runs the search and asserts at least one of these IDs matches a live result. If none match, the gate rejects the write (the agent's claimed evidence does not survive a fresh query)."),
-        disambiguatorOk: z
-            .boolean()
-            .optional()
-            .describe("Set to true ONLY when the chat-mention name carries an unambiguous disambiguator (full name 'Sarah Chen', explicit role context 'Sarah at Acme', email/phone). Single-first-name mentions without this flag are rejected as 'first-name-only' regardless of memory-search hit count."),
-        operatorConfirmed: z
-            .boolean()
-            .optional()
-            .describe("Set to true ONLY for RELATED_TO writes the operator has explicitly confirmed in chat. Defaults to false — every RELATED_TO without explicit confirmation is rejected to prevent inferred-relationship landfill."),
-        evidenceMessageIds: z
-            .array(z.string().min(1))
-            .optional()
-            .describe("For RELATED_TO: messageIds whose body evidenced the relationship. Stored as an edge property for forensic review."),
-        reason: z
-            .string()
-            .optional()
-            .describe("Free-text justification (one sentence) the operator can grep in audit logs. Not load-bearing for the gate; it's audit signal."),
-        sessionId: z
-            .string()
-            .optional()
-            .describe("Skill-run UUID for provenance. Falls back to SESSION_ID env var when absent."),
-    }, async (params) => {
-        try {
-            const result = await whatsappExportInsightWrite({
-                ...params,
-                accountId,
-                sessionId: resolveSessionId(params.sessionId),
-                allowedScopes,
-                envAgentSlug,
-                envKeywordSubscriptions,
-            });
-            return {
-                content: [{
-                        type: "text",
-                        text: JSON.stringify(result),
-                    }],
-            };
-        }
-        catch (err) {
-            return {
-                content: [{
-                        type: "text",
-                        text: `whatsapp-export-insight-write failed: ${err instanceof Error ? err.message : String(err)}`,
-                    }],
-                isError: true,
-            };
-        }
-    });
-    server.tool("whatsapp-export-preview", "Parse-only preview of a WhatsApp `_chat.txt` archive (Task 871). Returns parsed/skipped counts, " +
-        "the date range, the per-sender message histogram, the file's sha256, and total byte size — enough for the " +
-        "operator to choose a `--filter` value (`all`, `senders=<csv>`, `date-range=<isoFrom>..<isoTo>`) before invoking " +
-        "the deterministic Bash entry `whatsapp-ingest.sh`. Read-only: NO Cypher writes, NO Neo4j connection. " +
-        "Phase 1 contract — preview-then-filter-then-write. Pair with `whatsapp-ingest.sh` (Phase 1 archive-write) " +
-        "and `whatsapp-export-insight-pass` (Phase 2 enrichment) — the three tools cover the two-phase WhatsApp " +
-        "ingest pipeline.", {
-        filePath: z
-            .string()
-            .min(1)
-            .describe("Absolute path to the `_chat.txt` file (typically the operator-supplied archive path resolved against the attachment store)."),
-        timezone: z
-            .string()
-            .min(1)
-            .describe("IANA timezone the operator confirmed (e.g. 'Europe/London'). Same parameter as the parser; controls how the parsed timestamps render for the dateRange field."),
-        dateFormat: z
-            .enum(["DD/MM/YY", "MM/DD/YY", "DD/MM/YYYY", "MM/DD/YYYY"])
-            .optional()
-            .describe("Override auto-detected date ordering / year shape. Same enum as `whatsapp-export-parse`. Omit unless the operator confirms a US-locale export or a manually concatenated multi-locale archive."),
-    }, async ({ filePath, timezone, dateFormat }) => {
-        try {
-            const result = await whatsappExportPreview({
-                filePath,
-                accountId,
-                timezone,
-                dateFormat,
-            });
-            return {
-                content: [{
-                        type: "text",
-                        text: JSON.stringify(result),
-                    }],
-            };
-        }
-        catch (err) {
-            return {
-                content: [{
-                        type: "text",
-                        text: `whatsapp-export-preview failed: ${err instanceof Error ? err.message : String(err)}`,
-                    }],
-                isError: true,
-            };
-        }
-    });
-    server.tool("whatsapp-export-insight-pass", "Phase 2 chunked-Haiku insight extraction over an already-loaded WhatsApp Conversation (Task 871). " +
-        "Walks the Messages of `:Conversation:WhatsAppConversation {conversationId}` in chronological order, " +
-        "chunks them at 50 messages with 5-message overlap, runs Haiku per chunk, and MERGE-keys " +
-        "`:Observation` nodes (kind ∈ {mention, task, preference, observed-relationship}) connected " +
-        "`:OBSERVED_IN`→Conversation. Server-side gates: confidence>=0.8 per item (lower-confidence items rejected before write). " +
-        "Idempotent — re-running collapses identical (conversationId, sourceMessageRef, kind, contentHash) into the same row. " +
-        "Phase 1 (`whatsapp-ingest.sh`) writes ZERO observations; this tool is the only sanctioned LLM entry for " +
-        "WhatsApp ingest. Operator triggers consciously via the `whatsapp-import-enrich` skill — never automatic on Phase 1 completion.", {
-        conversationId: z
-            .string()
-            .min(1)
-            .describe("conversationId of the already-loaded :Conversation:WhatsAppConversation. Phase 1 must have completed (`c.lastImportedAt IS NOT NULL`)."),
-        sessionId: z
-            .string()
-            .optional()
-            .describe("Skill-run UUID for provenance. Falls back to SESSION_ID env var when absent."),
-    }, async (params) => {
-        try {
-            const result = await whatsappExportInsightPass({
-                conversationId: params.conversationId,
-                accountId,
-                sessionId: resolveSessionId(params.sessionId),
-            });
-            return {
-                content: [{
-                        type: "text",
-                        text: JSON.stringify(result),
-                    }],
-            };
-        }
-        catch (err) {
-            return {
-                content: [{
-                        type: "text",
-                        text: `whatsapp-export-insight-pass failed: ${err instanceof Error ? err.message : String(err)}`,
-                    }],
-                isError: true,
-            };
-        }
-    });
     server.tool("memory-ingest-web", "Adapter for web-content ingestion (Task 737). 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 " +
@@ -1587,7 +1354,7 @@ if (!readOnly) {
             await dbSession.close();
         }
     });
-    server.tool("profile-update", "Create, update, or reinforce a user preference; set top-level UserProfile fields (timezone, locale, givenName, role, expertise) via profileFields; AND set operator-identity fields (email, telephone) on the operator's personal-profile Person via personFields (Task 886 §D — Person is the canonical operator-identity store; UserProfile carries preferences and behavioural state only). Supports modes: reinforce (re-observed, boost confidence), update (value changed), contradict (value contradicts prior), merge (combine overlapping preferences).", {
+    server.tool("profile-update", "Create, update, or reinforce a user preference; set top-level UserProfile fields via profileFields; AND set Person properties on the operator's personal-profile Person via personFields. The personal-profile Person is open by default — pass any Person properties that help the agent assist this operator effectively (identity, contact, context, anything that makes future assistance more useful). The schema validator enforces rules centrally: synonyms reject (e.g. `phone` → use `telephone`), Forbidden Properties reject (e.g. `name` → use `givenName` + `familyName`), and any other key the agent judges useful is permitted. Writes route to the personal-profile Person via the OWNS edge from the AdminUser — the tool throws loudly if that edge is missing rather than silently no-oping. Supports modes: reinforce (re-observed, boost confidence), update (value changed), contradict (value contradicts prior), merge (combine overlapping preferences).", {
         category: z.enum(["communication", "scheduling", "decision", "workflow", "content", "interaction"])
             .describe("Preference category"),
         key: z.string().describe("Preference identifier (e.g. 'response_length', 'meeting_time')"),
@@ -1600,11 +1367,8 @@ if (!readOnly) {
             .describe("Conversation ID for evidence linking"),
         profileFields: z.record(z.string(), z.unknown()).optional()
             .describe("Top-level UserProfile fields to update (e.g. timezone, locale, role)"),
-        personFields: z.object({
-            email: z.string().optional(),
-            telephone: z.string().optional(),
-        }).optional()
-            .describe("Operator-identity fields written to the OWNS-bound Person (Task 886 §D). Use canonical `telephone` (NOT `phone` — that is the schema synonym, not the canonical name). Tool throws if the AdminUser-OWNS-Person edge is missing rather than silently no-op."),
+        personFields: z.record(z.string(), z.unknown()).optional()
+            .describe("Person properties to set on the operator's personal-profile Person — open by default; the agent decides which keys best help it serve this operator (identity, contact, context). Synonyms and Forbidden Properties are rejected by the central schema validator with descriptive errors; everything else is permitted."),
         mergeSourceIds: z.array(z.string()).optional()
             .describe("For mode 'merge': preferenceIds of sources to combine into this preference"),
     }, async ({ category, key, value, source, mode, conversationId, profileFields, personFields, mergeSourceIds }) => {
@@ -1622,8 +1386,9 @@ if (!readOnly) {
                 mode,
                 conversationId,
                 profileFields: profileFields,
-                personFields,
+                personFields: personFields,
                 mergeSourceIds,
+                validator,
             });
             return {
                 content: [{