@rubytech/create-realagent 1.0.826 → 1.0.829

package/payload/platform/plugins/memory/references/schema-base.md

@@ -37,13 +37,16 @@ When loading this reference, confirm which schema files were consulted by noting
 | CloudflareTunnel | `CloudflareTunnel` | platform-native | — | `accountId`, `tunnelId`, `tunnelName` |
 | CloudflareHostname | `CloudflareHostname` | platform-native | — | `accountId`, `hostnameValue`, `tunnelId` |
 | Position | `Position` | platform-native (analogue of `schema:OrganizationRole`) | — | `accountId`, `title`, `startDate` |
-| WhatsApp Conversation | `WhatsAppConversation` | extends `schema:Conversation` | — | `accountId`, `conversationId`, `archiveSourceFile`, `firstMessageAt`, `lastMessageAt`, `participantCount`, `messageCount`, `scope`, `createdByAgent`, `createdBySession`, `createdAt` |
-| WhatsApp Message | `WhatsAppMessage` | extends `schema:Message` | — | `accountId`, `conversationId`, `messageId`, `dateSent`, `body`, `senderName`, `sequenceIndex`, `scope`, `createdByAgent`, `createdBySession`, `createdAt` |
+| WhatsApp Conversation (legacy) | `WhatsAppConversation` | extends `schema:Conversation` | — | `accountId`, `conversationId`, `archiveSourceFile`, `firstMessageAt`, `lastMessageAt`, `participantCount`, `messageCount`, `scope`, `createdByAgent`, `createdBySession`, `createdAt` |
+| WhatsApp Message (legacy) | `WhatsAppMessage` | extends `schema:Message` | — | `accountId`, `conversationId`, `messageId`, `dateSent`, `body`, `senderName`, `sequenceIndex`, `scope`, `createdByAgent`, `createdBySession`, `createdAt` |
+| ConversationArchive (Task 891) | `ConversationArchive` | platform-native (chunked WhatsApp / messaging archive parent) | — | `accountId`, `conversationIdentity`, `archiveSourceFile`, `summary`, `keywords`, `lastIngestedMessageHash`, `lastIngestedMessageAt`, `lastIngestedArchiveSha256`, `scope`, `createdByAgent`, `createdBySession`, `createdAt` |
 
 **Branding properties on LocalBusiness:** `primaryColor`, `accentColor`, `backgroundColor`, `tagline` — optional, used to brand the public chat endpoint. Written via `memory-update` on the LocalBusiness node. Hex color values must match `#[0-9a-fA-F]{3,8}`. Logo and icon are linked via `HAS_BRAND_ASSET → ImageObject` with `purpose: "logo"` or `"icon"`.
 
 **Personal-profile role on Person (Task 704):** the optional `role` property on a `Person` node carries the value `"admin-personal"` when the node is the operator's personal-profile bootstrap (onboarding step 9 personal mode). The graph-write gate accepts `Person {role: "admin-personal"}` in lieu of a `LocalBusiness` so personal-mode users can complete onboarding without registering a business. Do not set `role: "admin-personal"` on customer or staff Person nodes — it's the personal-profile discriminator and only the bootstrap node should carry it.
 
+**Personal-profile Person is open by default (Task 893).** Any Person property the agent judges useful for serving the operator is permitted on the personal-profile Person — identity, contact, context, anything that makes future assistance more useful. The set is comprehensive, not enumerated. The only constraints are the Forbidden Properties table (Task 849; e.g. `Person.name` rejects in favour of `givenName` + `familyName`) and the Schema.org synonym table (e.g. `phone` rejects in favour of `telephone`). The schema validator is the central enforcement; callers do not pre-rewrite or pre-filter. The `profile-update` tool's `personFields` parameter is the conversational surface that writes here, validating in `mode: "update"` so SET-only writes do not re-run the required-property check (givenName/familyName were established at PIN setup).
+
 **CreativeWork** covers long-form textual records written by the platform: session summaries (`session-compact`), workflow digests (e.g. public chat review), and skill definitions saved by `skill-builder`. The `title` is a short identifier; the `abstract` carries the full content that drives the embedding.
 
 **DefinedTerm** covers reusable concepts, learnings, and glossary entries — e.g. project retrospective learnings (`name` is a short handle, `description` is the full learning). Additional properties like `category` are encouraged but not required.
@@ -165,6 +168,8 @@ The closed enumeration:
 
 `Preface`, `Abstract` (alias for Summary / ExecutiveSummary), `Introduction`, `TableOfContents`, `Chapter`, `Conclusion`, `Appendix`, `Bibliography` (alias for References), `Glossary`, `Acknowledgments` — each becomes `:Section:<Kind>` linked to the document via `(:KnowledgeDocument)-[:HAS_SECTION]->` and chained to siblings via `(:Section)-[:NEXT]->(:Section)` in reading order.
 
+`Conversation` (Task 891) — chat-mode chunks emitted by `memory-classify` with `mode='chat'`. Becomes `:Section:Conversation` linked via `(:ConversationArchive)-[:HAS_SECTION]->` (a different parent than KnowledgeDocument). Properties beyond the base section shape: `summary`, `keywords`, `firstMessageAt`, `lastMessageAt`, `participantNames`, `messageCount`, `archiveSha256`. The `:Section` validator rules (embedding, body, position) apply uniformly.
+
 **Contract-clause kinds (HAS_SECTION + NEXT, plus special-case extras for two kinds):**
 
 `Parties`, `Recitals`, `Definitions`, `Scope`, `Term`, `Payment`, `Confidentiality`, `IntellectualProperty`, `Warranties`, `Indemnification`, `Liability`, `Termination`, `GoverningLaw`, `ForceMajeure`, `Notices`, `EntireAgreement`, `Amendment`, `Assignment`, `Severability`, `Signatures`.

package/payload/platform/plugins/memory/skills/document-ingest/SKILL.md

@@ -1,11 +1,27 @@
 ---
 name: document-ingest
-description: Universal document ingestion — maps any unstructured document (PDF, text, transcript, web page) to ontologically-grounded `:Section` graph nodes via Haiku-driven classification. Triggers when the operator uploads or fetches a document for ingestion. One skill for every document type — no per-doctype branching.
+description: Universal document ingestion — maps any unstructured document (PDF, text, transcript, web page) OR chat archive (WhatsApp `_chat.txt`) to ontologically-grounded graph nodes via Haiku-driven classification. Triggers when the operator uploads or fetches a document or chat export for ingestion. One skill for every input shape — no per-doctype, no per-channel branching.
 ---
 
 # Document Ingest
 
-Ingests any unstructured document (PDF, text, transcript, web page) into the graph. Every classified section becomes one `:Section` node carrying a secondary label from a closed enumeration (`:Section:Position`, `:Section:Chapter`, `:Section:Parties`, …); identity-kind anchor edges go from the document subject directly at the multi-labeled section node. There are no per-doctype skills (no `cv-import`, no `contract-import`) — the classifier in `memory-classify` decides which kind every section maps to. The skill orchestrates the pipeline; the classifier reads the loaded ontology; the writer enforces the validator. **Classifier failure is terminal — the ingest aborts entirely; nothing is written. Loud failures, never silent landfill.**
+Ingests any unstructured input — documents (PDF, text, transcript, web page) and chat archives (WhatsApp `_chat.txt`) — into the graph. Every classified section becomes one `:Section` node. **Two parent shapes, one pipeline:**
+
+| Input shape | Parent label | Section secondary label | Identity property | mode |
+|---|---|---|---|---|
+| PDF / text / web (default) | `:KnowledgeDocument` | `:Section:<Kind>` from closed enumeration (`Position`, `Chapter`, `Parties`, …) | `attachmentId` | `document` |
+| Chat archive (`_chat.txt`) | `:ConversationArchive` | `:Section:Conversation` | `conversationIdentity` | `chat` |
+
+The classifier in `memory-classify` decides which section kinds each section maps to (document mode) or chunks the archive into topic-bounded `:Section:Conversation` nodes (chat mode). The skill orchestrates the pipeline; the classifier reads the loaded ontology; the writer enforces the validator. **Classifier failure is terminal — the ingest aborts entirely; nothing is written. Loud failures, never silent landfill.**
+
+## Routing — chat vs document (mandatory first decision)
+
+Before anchor confirmation, decide the parent shape from the input:
+
+- **Chat archive** — input filename ends in `_chat.txt`, the dispatch brief names the input as a WhatsApp chat / messaging-channel export, or the operator labels it as such. Set `mode='chat'` and `parentLabel='ConversationArchive'`. Skip anchor confirmation; run participant confirmation instead (see § Participant confirmation). The classifier produces `:Section:Conversation` chunks; no anchor edges, no related entities.
+- **Document** — everything else. Set `mode='document'` and `parentLabel='KnowledgeDocument'` (or omit — these are the defaults). Run the anchor confirmation flow below.
+
+Both branches go through the same three tools (`memory-ingest-extract` → `memory-classify` → `memory-ingest`); only the parameters differ.
 
 ## Anchor confirmation (mandatory first step)
 
@@ -27,6 +43,26 @@ The confirmation flow:
 3. Run a one-shot graph read to resolve the anchor's element ID. For UserProfile: `MATCH (u:UserProfile {accountId: $accountId}) RETURN elementId(u) AS anchorId, 'UserProfile' AS anchorLabel`. For LocalBusiness: `MATCH (b:LocalBusiness {accountId: $accountId}) RETURN elementId(b) AS anchorId, 'LocalBusiness' AS anchorLabel`. For a third party: search by name via `memory-search` and pick the matching node.
 4. Persist `$anchorNodeId` and `$anchorLabel` for the rest of the run. These flow into both `memory-classify` (as part of the `anchorDescription`) and `memory-ingest` (as the `anchorNodeId` + `anchorLabel` parameters).
 
+## Participant confirmation (chat mode only)
+
+Chat archives are multi-party — no single subject anchor. Instead, every distinct sender name in the archive must resolve to an existing `:AdminUser` or `:Person` elementId before any classify or ingest call. No auto-creation; missing participants are blockers, not silent skips.
+
+The confirmation flow:
+
+1. Read the dispatch brief. Extract the archive path and any operator-stated participant identities.
+2. Read a small sample of the archive (head ~50 lines) via the `Read` tool to discover the distinct sender names that appear at line starts after the bracketed-timestamp prefix.
+3. For every distinct senderName, search the graph via `memory-search` (or a one-shot `MATCH (n) WHERE (n:Person OR n:AdminUser) AND n.accountId = $accountId AND (n.name = $name OR (n.givenName + ' ' + n.familyName) = $name) RETURN elementId(n)`).
+4. **Resolved fully** — every senderName mapped to exactly one elementId. Capture the owner's elementId (the operator who exported the archive — usually the `:AdminUser` for this account; ask if ambiguous) and the comma-separated list of remaining participant elementIds.
+5. **Unresolved** — at least one senderName has no matching node. Surface to the operator: *"Archive `<filename>` mentions sender `<name>` but no `:Person` / `:AdminUser` matches. Create the contact first or correct the name, then re-dispatch."* Do NOT proceed.
+6. **Ambiguous** — a senderName matches multiple nodes. Ask the operator which one. Do NOT proceed until disambiguated.
+
+Persist `$ownerElementId` and `$participantElementIds` (array, owner excluded) for the run. These flow into `memory-ingest` as the `participantElementIds` parameter (owner + others, deduped).
+
+Compute archive metadata before classify:
+- `archiveSha256` — `bash sha256sum "<file>" | cut -d' ' -f1`. Stamped on the parent + every chunk.
+- `archiveSourceFile` — the basename (e.g. `_chat.txt`).
+- `conversationIdentity` — pass as the `attachmentId` parameter to `memory-ingest`. Format: `chat:<sha256(accountId + ":" + sortedParticipantElementIds)>` where `sortedParticipantElementIds` is the sorted-then-comma-joined list of `[owner, ...participants]`. Same conversation across re-exports → same identity → idempotent MERGE on the `:ConversationArchive`.
+
 ## Pipeline
 
 Four steps in order. Steps 1–3 are deterministic tool calls (the agent does not classify; the agent calls the classifier tool). Step 4 is agent-driven graph writes against the existing graph, gated by the dispatch brief's named entity list. Hallucination defence and ontology validation stay server-side in `memory-classify` and the `memory-write` validator.
@@ -68,7 +104,13 @@ Form: "Classifying `<filename>` (`<N>` chars) — expect ~`<estimate>`."
 
 ### 2. `memory-classify`
 
-Calls Haiku with the loaded ontology and the cached text. Inputs: `attachmentId` (same one), `anchorDescription` (a short sentence built from the confirmed anchor — e.g. `"subject = UserProfile (the account owner); edges from UserProfile."` or `"subject = LocalBusiness {name: 'Acme Roofing'} (the operator's business); edges from LocalBusiness."`). Returns:
+Calls Haiku with the loaded ontology and the cached text.
+
+**Document mode (default).** Inputs: `attachmentId` (same one), `anchorDescription` (a short sentence built from the confirmed anchor — e.g. `"subject = UserProfile (the account owner); edges from UserProfile."` or `"subject = LocalBusiness {name: 'Acme Roofing'} (the operator's business); edges from LocalBusiness."`).
+
+**Chat mode.** Inputs: `attachmentId` (same one), `mode='chat'`, `anchorDescription` (a short sentence naming the conversation — e.g. `"WhatsApp conversation between Joel and Adam (2 participants)"`). The chat prompt drops the natural-edge map, the closed enumeration, and the orphan logic — Haiku produces topic-bounded `:Section:Conversation` chunks with `summary`, `keywords`, `firstMessageAt`, `lastMessageAt`, `participantNames`, `messageCount` per chunk. The whole archive may produce one chunk (short conversation) or many (long chat with topic transitions); chunks cover every message in chronological order with no gaps.
+
+Returns:
 
 - `documentSummary` — 1-3 sentences for the KnowledgeDocument node
 - `documentKeywords` — 3-10 lowercase topic keywords
@@ -83,7 +125,13 @@ After step 2 succeeds, emit a chat message before step 3 naming what the classif
 
 ### 3. `memory-ingest`
 
-Writes the classified document. Inputs: `attachmentId`, `documentSummary`, `anchorNodeId`, `anchorLabel`, `sections`, `documentEdges` (pass through if present), `orphanCandidates` (pass through if present), `scope` (from the brief — confirm with the operator if absent), optional `documentKeywords`, `userKeywords`, `sourceUrl`, `sourceType`. Returns:
+Writes the classified document or chat archive.
+
+**Document mode (default).** Inputs: `attachmentId`, `documentSummary`, `anchorNodeId`, `anchorLabel`, `sections`, `documentEdges` (pass through if present), `orphanCandidates` (pass through if present), `scope` (from the brief — confirm with the operator if absent), optional `documentKeywords`, `userKeywords`, `sourceUrl`, `sourceType`.
+
+**Chat mode.** Inputs: `attachmentId` (set to `conversationIdentity`), `parentLabel='ConversationArchive'`, `documentSummary`, `sections` (the chunks from chat-mode classify), `scope`, plus the chat-archive metadata: `archiveSha256` (cleanup discriminator), `archiveSourceFile` (audit), `participantElementIds` (owner + others, for `:PARTICIPANT_IN` edges). Pass `anchorNodeId` and `anchorLabel` as any non-empty placeholder (e.g. the owner's elementId + `'AdminUser'`) — they are unused on the chat path but the parameter is non-optional. The writer MERGEs `:ConversationArchive { conversationIdentity }`, drops any chunks stamped with this `archiveSha256` (idempotent re-ingest), CREATEs new chunks chained by `:NEXT`, and MERGEs `:PARTICIPANT_IN` edges from each participant.
+
+Returns:
 
 - `documentNodeId`, `sectionCount`
 - `kindBreakdown` — per-kind count, e.g. `{"Position": 4, "Chapter": 12, "Other": 1}`
@@ -99,6 +147,8 @@ Re-ingesting the same `attachmentId` is safe — the writer drops prior `:Sectio
 
 ### 4. `wire-brief-entities`
 
+**Skipped in chat mode** — `:ConversationArchive` does not carry KD-level brief-wired edges; participants are already attached via `:PARTICIPANT_IN` and message bodies stay verbatim inside chunk text (mention extraction is deferred to a separate insight-derivation task). Document mode only.
+
 After `memory-ingest` returns the new KnowledgeDocument's `documentNodeId`, this step iterates the entities the dispatch brief named and connects each to the new document with the natural KD-level edge.
 
 **Entity sources.** The dispatch brief's "key entities to connect" list. Brief shape: prose names of Persons, Organizations, Services, Tasks, Events, KnowledgeDocuments, BrandingData that the document describes or references. Example: *"Person nodes for Joel Smalley, Adam Mackay, Dan McLeod; LocalBusiness / Organization nodes for Real Agent / Real Agency; Any existing Task nodes related to Real Agent Lettings."* Extract every named entity from the brief before any `memory-write`.

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

@@ -51,7 +51,7 @@ When per-group activation is `mention`, the agent fires only if the inbound mess
 
 ## Live persistence
 
-Every `messages.upsert` event (both `notify` and `append`, both `fromMe` directions) writes a `:Message:WhatsAppMessage` row to Neo4j attached to the sessionKey-keyed `:Conversation`. A single capture site at `platform/ui/app/lib/whatsapp/manager.ts` covers inbound, outbound (Baileys echoes agent-sent messages back through `messages.upsert` with `fromMe=true`), and owner-mirror — without touching `outbound/send.ts`. `messageId` namespace is `whatsapp-live:<waName>:<remoteJid>:<msg.key.id>` where `<waName>` is the Baileys credential dirname (e.g. `default`); collision-free with the `whatsapp-export:` namespace used by the offline `whatsapp-import` plugin. Persist failures are loud (`[whatsapp-persist] FAIL …`) and never block dispatch — silent loss is the worse failure mode.
+Every `messages.upsert` event (both `notify` and `append`, both `fromMe` directions) writes a `:Message:WhatsAppMessage` row to Neo4j attached to the sessionKey-keyed `:Conversation`. A single capture site at `platform/ui/app/lib/whatsapp/manager.ts` covers inbound, outbound (Baileys echoes agent-sent messages back through `messages.upsert` with `fromMe=true`), and owner-mirror — without touching `outbound/send.ts`. `messageId` namespace is `whatsapp-live:<waName>:<remoteJid>:<msg.key.id>` where `<waName>` is the Baileys credential dirname (e.g. `default`). The live plugin writes `:Message:WhatsAppMessage` rows; offline `_chat.txt` archives are document-shaped narrative and route through `document-ingest` with `parentLabel='ConversationArchive'` (unified-ingest pipeline migration) producing `:Section:Conversation` chunks — entity types differ, no namespace collision. Persist failures are loud (`[whatsapp-persist] FAIL …`) and never block dispatch — silent loss is the worse failure mode.
 
 **`accountId` contract.** `n.accountId` on every `:Conversation`, `:Person`, and `:Message:WhatsAppMessage` row stamped by this plugin is the **platform-side UUID** resolved by [`resolvePlatformAccountId()`](../../ui/app/lib/whatsapp/platform-account-id.ts) from `data/accounts/<uuid>/account.json` — NOT the Baileys credential dirname (which is only used as the `messageId`/`sessionKey` namespace token). The boot-time line `[whatsapp-persist] resolved-account-id waname=<dir> uuid=<uuid>` records the resolution. Doctrine: see `.docs/neo4j.md` "Account isolation invariant" — migration 004 `pruneAlienAccounts` `DETACH DELETE`s any node whose `accountId` is not a UUID dir on every boot. The helper loud-throws on zero or multi accounts (Phase 0 single-account invariant), aborting the WhatsApp connection start before any write can occur.
 

package/payload/platform/plugins/whatsapp-import/lib/dist/delta-cursor.d.ts

@@ -0,0 +1,18 @@
+import type { ParsedLine } from "./parse-export.js";
+export type CursorResult = {
+    kind: "found";
+    deltaStart: number;
+} | {
+    kind: "empty";
+} | {
+    kind: "missing";
+};
+/**
+ * Walk parsed lines forward and return the first index whose content hash
+ * matches `lastIngestedMessageHash`. The first match is correct because
+ * messages with identical (dateSent, normalisedSenderName, body) tuples
+ * are genuine duplicates — there is no way to disambiguate them and slicing
+ * after the first occurrence is the chronologically safe choice.
+ */
+export declare function findDeltaCursor(parsedLines: readonly ParsedLine[], lastIngestedMessageHash: string): CursorResult;
+//# sourceMappingURL=delta-cursor.d.ts.map

package/payload/platform/plugins/whatsapp-import/lib/dist/delta-cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delta-cursor.d.ts","sourceRoot":"","sources":["../src/delta-cursor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAqBpD,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GACrC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC;AAExB;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,WAAW,EAAE,SAAS,UAAU,EAAE,EAClC,uBAAuB,EAAE,MAAM,GAC9B,YAAY,CAiBd"}

package/payload/platform/plugins/whatsapp-import/lib/dist/delta-cursor.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findDeltaCursor = findDeltaCursor;
+const derive_keys_js_1 = require("./derive-keys.js");
+/**
+ * Walk parsed lines forward and return the first index whose content hash
+ * matches `lastIngestedMessageHash`. The first match is correct because
+ * messages with identical (dateSent, normalisedSenderName, body) tuples
+ * are genuine duplicates — there is no way to disambiguate them and slicing
+ * after the first occurrence is the chronologically safe choice.
+ */
+function findDeltaCursor(parsedLines, lastIngestedMessageHash) {
+    if (!lastIngestedMessageHash || !lastIngestedMessageHash.trim()) {
+        throw new Error("findDeltaCursor: lastIngestedMessageHash must be non-empty");
+    }
+    for (let i = 0; i < parsedLines.length; i++) {
+        const line = parsedLines[i];
+        const hash = (0, derive_keys_js_1.deriveMessageContentHash)({
+            dateSent: line.dateSent,
+            senderName: line.senderName,
+            body: line.body,
+        });
+        if (hash === lastIngestedMessageHash) {
+            if (i === parsedLines.length - 1)
+                return { kind: "empty" };
+            return { kind: "found", deltaStart: i + 1 };
+        }
+    }
+    return { kind: "missing" };
+}
+//# sourceMappingURL=delta-cursor.js.map

package/payload/platform/plugins/whatsapp-import/lib/dist/delta-cursor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delta-cursor.js","sourceRoot":"","sources":["../src/delta-cursor.ts"],"names":[],"mappings":";;AAiCA,0CAoBC;AApDD,qDAA4D;AAyB5D;;;;;;GAMG;AACH,SAAgB,eAAe,CAC7B,WAAkC,EAClC,uBAA+B;IAE/B,IAAI,CAAC,uBAAuB,IAAI,CAAC,uBAAuB,CAAC,IAAI,EAAE,EAAE,CAAC;QAChE,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;IAChF,CAAC;IACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC5C,MAAM,IAAI,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;QAC5B,MAAM,IAAI,GAAG,IAAA,yCAAwB,EAAC;YACpC,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,IAAI,EAAE,IAAI,CAAC,IAAI;SAChB,CAAC,CAAC;QACH,IAAI,IAAI,KAAK,uBAAuB,EAAE,CAAC;YACrC,IAAI,CAAC,KAAK,WAAW,CAAC,MAAM,GAAG,CAAC;gBAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;YAC3D,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;QAC9C,CAAC;IACH,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;AAC7B,CAAC"}

package/payload/platform/plugins/whatsapp-import/lib/dist/derive-keys.d.ts

@@ -1,21 +1,36 @@
 export declare function normaliseSenderName(name: string): string;
 export declare function sha256Hex(input: string): string;
-export interface DeriveMessageIdInput {
-    /** SHA-256 of the source `_chat.txt` bytes — stable across re-imports. */
-    conversationSha256: string;
+export interface DeriveConversationIdentityInput {
+    accountId: string;
+    /**
+     * Element IDs of every confirmed participant (owner + others). Order is
+     * not significant; the function sorts internally so the same set always
+     * produces the same identity.
+     */
+    participantElementIds: readonly string[];
+}
+/**
+ * Compute the stable identity for a conversation. Same accountId + same
+ * participant set ⇒ same identity, regardless of message content or export
+ * file bytes. DM and group chats use this identical formula.
+ */
+export declare function deriveConversationIdentity(input: DeriveConversationIdentityInput): string;
+export interface DeriveMessageContentHashInput {
     /** ISO 8601 with timezone offset, as emitted by parseExport. */
     dateSent: string;
     /** Raw senderName from the export line. Normalised internally. */
     senderName: string;
-    /** Raw message body. Hashed internally. */
+    /** Raw message body. */
     body: string;
 }
-export declare function deriveMessageId(input: DeriveMessageIdInput): string;
-export interface ObservationContentFields {
-    summary?: string | null;
-    from?: string | null;
-    to?: string | null;
-    subject?: string | null;
-}
-export declare function observationContentHash(fields: ObservationContentFields): string;
+/**
+ * Compute a content-only hash for a single message. Used as the delta-append
+ * cursor: `:ConversationArchive.lastIngestedMessageHash` records the hash of
+ * the last ingested message; on re-import, the orchestrator finds the line
+ * with the matching hash and slices everything after it.
+ *
+ * Excludes archive sha256 deliberately — the cursor must survive a fresh
+ * re-export of the same chat (different file bytes, same message tuples).
+ */
+export declare function deriveMessageContentHash(input: DeriveMessageContentHashInput): string;
 //# sourceMappingURL=derive-keys.d.ts.map

package/payload/platform/plugins/whatsapp-import/lib/dist/derive-keys.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"derive-keys.d.ts","sourceRoot":"","sources":["../src/derive-keys.ts"],"names":[],"mappings":"AAqBA,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED,MAAM,WAAW,oBAAoB;IACnC,0EAA0E;IAC1E,kBAAkB,EAAE,MAAM,CAAC;IAC3B,gEAAgE;IAChE,QAAQ,EAAE,MAAM,CAAC;IACjB,kEAAkE;IAClE,UAAU,EAAE,MAAM,CAAC;IACnB,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,GAAG,MAAM,CAInE;AAED,MAAM,WAAW,wBAAwB;IACvC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,wBAAwB,GAAG,MAAM,CAK/E"}
+{"version":3,"file":"derive-keys.d.ts","sourceRoot":"","sources":["../src/derive-keys.ts"],"names":[],"mappings":"AAsBA,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED,MAAM,WAAW,+BAA+B;IAC9C,SAAS,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,qBAAqB,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,+BAA+B,GACrC,MAAM,CASR;AAED,MAAM,WAAW,6BAA6B;IAC5C,gEAAgE;IAChE,QAAQ,EAAE,MAAM,CAAC;IACjB,kEAAkE;IAClE,UAAU,EAAE,MAAM,CAAC;IACnB,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,6BAA6B,GACnC,MAAM,CAGR"}

package/payload/platform/plugins/whatsapp-import/lib/dist/derive-keys.js

@@ -2,26 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normaliseSenderName = normaliseSenderName;
 exports.sha256Hex = sha256Hex;
-exports.deriveMessageId = deriveMessageId;
-exports.observationContentHash = observationContentHash;
+exports.deriveConversationIdentity = deriveConversationIdentity;
+exports.deriveMessageContentHash = deriveMessageContentHash;
 const node_crypto_1 = require("node:crypto");
 // ---------------------------------------------------------------------------
-// derive-keys — natural-key derivation for whatsapp-import (Task 870).
+// derive-keys — natural-key derivation for whatsapp-import (Task 891,
+// supersedes Task 870's per-message contract).
 //
 // Pure functions. No I/O. The whole point is that re-imports of the same
-// archive collapse to the same Message identity regardless of release-level
-// drift in array indices, hash widths, or arbitrary tiebreakers.
+// archive collapse to the same identity regardless of release-level drift in
+// chunk indices, hash widths, or arbitrary tiebreakers.
 //
-// Key shape (Task 870 brief):
+// Identity contracts (Task 891 brief):
 //
-//   messageId = whatsapp-export:msg:<conversationSha256>:<dateSentISO>
-//                                  :<NFKC-trim-lower(senderName)>
-//                                  :<sha256-hex(body)>
+//   conversationIdentity   = sha256(accountId + ":" + sortedParticipantElementIds.join(","))
+//   messageContentHash     = sha256(dateSent + "|" + NFKC-trim-lower(senderName) + "|" + body)
 //
-// Operator constraint: the same archive must be re-imported with the same
-// `--timezone` flag. Different timezones reinterpret wall-clock instants and
-// will produce drifted messageIds — that is correct semantics, not a bug.
-// Documented in .docs/whatsapp.md natural-key contract section.
+// `conversationIdentity` is stable across re-exports — same operator + same
+// participant set → same identity, regardless of file bytes. DM and group
+// follow the same formula; the difference is the participant array length.
+// `messageContentHash` is content-only (no archive sha256, no chunk index)
+// so cursor lookup survives a fresh re-export of the same chat.
 // ---------------------------------------------------------------------------
 function normaliseSenderName(name) {
     return name.normalize("NFKC").trim().toLowerCase();
@@ -29,13 +30,32 @@ function normaliseSenderName(name) {
 function sha256Hex(input) {
     return (0, node_crypto_1.createHash)("sha256").update(input).digest("hex");
 }
-function deriveMessageId(input) {
-    const norm = normaliseSenderName(input.senderName);
-    const bodyHash = sha256Hex(input.body);
-    return `whatsapp-export:msg:${input.conversationSha256}:${input.dateSent}:${norm}:${bodyHash}`;
+/**
+ * Compute the stable identity for a conversation. Same accountId + same
+ * participant set ⇒ same identity, regardless of message content or export
+ * file bytes. DM and group chats use this identical formula.
+ */
+function deriveConversationIdentity(input) {
+    if (!input.accountId || !input.accountId.trim()) {
+        throw new Error("deriveConversationIdentity: accountId is required");
+    }
+    if (input.participantElementIds.length === 0) {
+        throw new Error("deriveConversationIdentity: participantElementIds must be non-empty");
+    }
+    const sorted = [...input.participantElementIds].sort();
+    return sha256Hex(`${input.accountId}:${sorted.join(",")}`);
 }
-function observationContentHash(fields) {
-    const parts = [fields.summary, fields.from, fields.to, fields.subject].map((p) => (p ?? "").normalize("NFKC").trim().toLowerCase());
-    return sha256Hex(parts.join("|"));
+/**
+ * Compute a content-only hash for a single message. Used as the delta-append
+ * cursor: `:ConversationArchive.lastIngestedMessageHash` records the hash of
+ * the last ingested message; on re-import, the orchestrator finds the line
+ * with the matching hash and slices everything after it.
+ *
+ * Excludes archive sha256 deliberately — the cursor must survive a fresh
+ * re-export of the same chat (different file bytes, same message tuples).
+ */
+function deriveMessageContentHash(input) {
+    const norm = normaliseSenderName(input.senderName);
+    return sha256Hex(`${input.dateSent}|${norm}|${input.body}`);
 }
 //# sourceMappingURL=derive-keys.js.map

package/payload/platform/plugins/whatsapp-import/lib/dist/derive-keys.js.map

@@ -1 +1 @@
-{"version":3,"file":"derive-keys.js","sourceRoot":"","sources":["../src/derive-keys.ts"],"names":[],"mappings":";;AAqBA,kDAEC;AAED,8BAEC;AAaD,0CAIC;AASD,wDAKC;AA1DD,6CAAyC;AAEzC,8EAA8E;AAC9E,uEAAuE;AACvE,EAAE;AACF,yEAAyE;AACzE,4EAA4E;AAC5E,iEAAiE;AACjE,EAAE;AACF,8BAA8B;AAC9B,EAAE;AACF,uEAAuE;AACvE,kEAAkE;AAClE,uDAAuD;AACvD,EAAE;AACF,0EAA0E;AAC1E,6EAA6E;AAC7E,0EAA0E;AAC1E,gEAAgE;AAChE,8EAA8E;AAE9E,SAAgB,mBAAmB,CAAC,IAAY;IAC9C,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;AACrD,CAAC;AAED,SAAgB,SAAS,CAAC,KAAa;IACrC,OAAO,IAAA,wBAAU,EAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC1D,CAAC;AAaD,SAAgB,eAAe,CAAC,KAA2B;IACzD,MAAM,IAAI,GAAG,mBAAmB,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IACnD,MAAM,QAAQ,GAAG,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACvC,OAAO,uBAAuB,KAAK,CAAC,kBAAkB,IAAI,KAAK,CAAC,QAAQ,IAAI,IAAI,IAAI,QAAQ,EAAE,CAAC;AACjG,CAAC;AASD,SAAgB,sBAAsB,CAAC,MAAgC;IACrE,MAAM,KAAK,GAAG,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC,GAAG,CACxE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CACxD,CAAC;IACF,OAAO,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AACpC,CAAC"}
+{"version":3,"file":"derive-keys.js","sourceRoot":"","sources":["../src/derive-keys.ts"],"names":[],"mappings":";;AAsBA,kDAEC;AAED,8BAEC;AAiBD,gEAWC;AAoBD,4DAKC;AAjFD,6CAAyC;AAEzC,8EAA8E;AAC9E,sEAAsE;AACtE,+CAA+C;AAC/C,EAAE;AACF,yEAAyE;AACzE,6EAA6E;AAC7E,wDAAwD;AACxD,EAAE;AACF,uCAAuC;AACvC,EAAE;AACF,6FAA6F;AAC7F,+FAA+F;AAC/F,EAAE;AACF,4EAA4E;AAC5E,0EAA0E;AAC1E,2EAA2E;AAC3E,2EAA2E;AAC3E,gEAAgE;AAChE,8EAA8E;AAE9E,SAAgB,mBAAmB,CAAC,IAAY;IAC9C,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;AACrD,CAAC;AAED,SAAgB,SAAS,CAAC,KAAa;IACrC,OAAO,IAAA,wBAAU,EAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC1D,CAAC;AAYD;;;;GAIG;AACH,SAAgB,0BAA0B,CACxC,KAAsC;IAEtC,IAAI,CAAC,KAAK,CAAC,SAAS,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,EAAE,CAAC;QAChD,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;IACvE,CAAC;IACD,IAAI,KAAK,CAAC,qBAAqB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7C,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAC;IACzF,CAAC;IACD,MAAM,MAAM,GAAG,CAAC,GAAG,KAAK,CAAC,qBAAqB,CAAC,CAAC,IAAI,EAAE,CAAC;IACvD,OAAO,SAAS,CAAC,GAAG,KAAK,CAAC,SAAS,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;AAC7D,CAAC;AAWD;;;;;;;;GAQG;AACH,SAAgB,wBAAwB,CACtC,KAAoC;IAEpC,MAAM,IAAI,GAAG,mBAAmB,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IACnD,OAAO,SAAS,CAAC,GAAG,KAAK,CAAC,QAAQ,IAAI,IAAI,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;AAC9D,CAAC"}

package/payload/platform/plugins/whatsapp-import/lib/dist/index.d.ts

@@ -1,7 +1,10 @@
 export { parseExport } from "./parse-export.js";
 export type { ParseExportInput, ParseExportResult, ParseExportCounters, ParsedLine, } from "./parse-export.js";
-export { parseFilterArg, applyFilter } from "./filter.js";
-export type { Filter } from "./filter.js";
-export { normaliseSenderName, sha256Hex, deriveMessageId, observationContentHash, } from "./derive-keys.js";
-export type { DeriveMessageIdInput, ObservationContentFields, } from "./derive-keys.js";
+export { normaliseSenderName, sha256Hex, deriveConversationIdentity, deriveMessageContentHash, } from "./derive-keys.js";
+export type { DeriveConversationIdentityInput, DeriveMessageContentHashInput, } from "./derive-keys.js";
+export { sessionize } from "./sessionize.js";
+export type { Session } from "./sessionize.js";
+export { toClassifierInput } from "./to-classifier-input.js";
+export { findDeltaCursor } from "./delta-cursor.js";
+export type { CursorResult } from "./delta-cursor.js";
 //# sourceMappingURL=index.d.ts.map

package/payload/platform/plugins/whatsapp-import/lib/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EACV,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,EACnB,UAAU,GACX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1D,YAAY,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EACL,mBAAmB,EACnB,SAAS,EACT,eAAe,EACf,sBAAsB,GACvB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,oBAAoB,EACpB,wBAAwB,GACzB,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EACV,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,EACnB,UAAU,GACX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,mBAAmB,EACnB,SAAS,EACT,0BAA0B,EAC1B,wBAAwB,GACzB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,+BAA+B,EAC/B,6BAA6B,GAC9B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,YAAY,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC"}

package/payload/platform/plugins/whatsapp-import/lib/dist/index.js

@@ -1,14 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.observationContentHash = exports.deriveMessageId = exports.sha256Hex = exports.normaliseSenderName = exports.applyFilter = exports.parseFilterArg = exports.parseExport = void 0;
+exports.findDeltaCursor = exports.toClassifierInput = exports.sessionize = exports.deriveMessageContentHash = exports.deriveConversationIdentity = exports.sha256Hex = exports.normaliseSenderName = exports.parseExport = void 0;
 var parse_export_js_1 = require("./parse-export.js");
 Object.defineProperty(exports, "parseExport", { enumerable: true, get: function () { return parse_export_js_1.parseExport; } });
-var filter_js_1 = require("./filter.js");
-Object.defineProperty(exports, "parseFilterArg", { enumerable: true, get: function () { return filter_js_1.parseFilterArg; } });
-Object.defineProperty(exports, "applyFilter", { enumerable: true, get: function () { return filter_js_1.applyFilter; } });
 var derive_keys_js_1 = require("./derive-keys.js");
 Object.defineProperty(exports, "normaliseSenderName", { enumerable: true, get: function () { return derive_keys_js_1.normaliseSenderName; } });
 Object.defineProperty(exports, "sha256Hex", { enumerable: true, get: function () { return derive_keys_js_1.sha256Hex; } });
-Object.defineProperty(exports, "deriveMessageId", { enumerable: true, get: function () { return derive_keys_js_1.deriveMessageId; } });
-Object.defineProperty(exports, "observationContentHash", { enumerable: true, get: function () { return derive_keys_js_1.observationContentHash; } });
+Object.defineProperty(exports, "deriveConversationIdentity", { enumerable: true, get: function () { return derive_keys_js_1.deriveConversationIdentity; } });
+Object.defineProperty(exports, "deriveMessageContentHash", { enumerable: true, get: function () { return derive_keys_js_1.deriveMessageContentHash; } });
+var sessionize_js_1 = require("./sessionize.js");
+Object.defineProperty(exports, "sessionize", { enumerable: true, get: function () { return sessionize_js_1.sessionize; } });
+var to_classifier_input_js_1 = require("./to-classifier-input.js");
+Object.defineProperty(exports, "toClassifierInput", { enumerable: true, get: function () { return to_classifier_input_js_1.toClassifierInput; } });
+var delta_cursor_js_1 = require("./delta-cursor.js");
+Object.defineProperty(exports, "findDeltaCursor", { enumerable: true, get: function () { return delta_cursor_js_1.findDeltaCursor; } });
 //# sourceMappingURL=index.js.map

package/payload/platform/plugins/whatsapp-import/lib/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,qDAAgD;AAAvC,8GAAA,WAAW,OAAA;AAOpB,yCAA0D;AAAjD,2GAAA,cAAc,OAAA;AAAE,wGAAA,WAAW,OAAA;AAEpC,mDAK0B;AAJxB,qHAAA,mBAAmB,OAAA;AACnB,2GAAA,SAAS,OAAA;AACT,iHAAA,eAAe,OAAA;AACf,wHAAA,sBAAsB,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,qDAAgD;AAAvC,8GAAA,WAAW,OAAA;AAOpB,mDAK0B;AAJxB,qHAAA,mBAAmB,OAAA;AACnB,2GAAA,SAAS,OAAA;AACT,4HAAA,0BAA0B,OAAA;AAC1B,0HAAA,wBAAwB,OAAA;AAM1B,iDAA6C;AAApC,2GAAA,UAAU,OAAA;AAEnB,mEAA6D;AAApD,2HAAA,iBAAiB,OAAA;AAC1B,qDAAoD;AAA3C,kHAAA,eAAe,OAAA"}

package/payload/platform/plugins/whatsapp-import/lib/dist/sessionize.d.ts

@@ -0,0 +1,25 @@
+import type { ParsedLine } from "./parse-export.js";
+export interface Session {
+    /** 0-based index across the archive's sessions. */
+    index: number;
+    /** ISO 8601 timestamp of the first message in the session. */
+    firstMessageAt: string;
+    /** ISO 8601 timestamp of the last message in the session. */
+    lastMessageAt: string;
+    /** Messages in the session, chronological. */
+    messages: ParsedLine[];
+}
+/**
+ * Split parsed messages into sessions on gaps ≥ `gapHours`. Input must be
+ * pre-sorted by `dateSent` (parse-export emits in file order, which IS
+ * chronological for any well-formed `_chat.txt`).
+ *
+ * Boundary semantics (exact-at-threshold):
+ *   gap == gapHours    → cut here (start a new session)
+ *   gap <  gapHours    → same session
+ *   gap >  gapHours    → cut here
+ *
+ * Empty input returns []; single-message input returns one one-message session.
+ */
+export declare function sessionize(messages: readonly ParsedLine[], gapHours: number): Session[];
+//# sourceMappingURL=sessionize.d.ts.map

package/payload/platform/plugins/whatsapp-import/lib/dist/sessionize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionize.d.ts","sourceRoot":"","sources":["../src/sessionize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAsBpD,MAAM,WAAW,OAAO;IACtB,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,8DAA8D;IAC9D,cAAc,EAAE,MAAM,CAAC;IACvB,6DAA6D;IAC7D,aAAa,EAAE,MAAM,CAAC;IACtB,8CAA8C;IAC9C,QAAQ,EAAE,UAAU,EAAE,CAAC;CACxB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CACxB,QAAQ,EAAE,SAAS,UAAU,EAAE,EAC/B,QAAQ,EAAE,MAAM,GACf,OAAO,EAAE,CAgCX"}

package/payload/platform/plugins/whatsapp-import/lib/dist/sessionize.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionize = sessionize;
+/**
+ * Split parsed messages into sessions on gaps ≥ `gapHours`. Input must be
+ * pre-sorted by `dateSent` (parse-export emits in file order, which IS
+ * chronological for any well-formed `_chat.txt`).
+ *
+ * Boundary semantics (exact-at-threshold):
+ *   gap == gapHours    → cut here (start a new session)
+ *   gap <  gapHours    → same session
+ *   gap >  gapHours    → cut here
+ *
+ * Empty input returns []; single-message input returns one one-message session.
+ */
+function sessionize(messages, gapHours) {
+    if (gapHours <= 0) {
+        throw new Error(`sessionize: gapHours must be positive, got ${gapHours}`);
+    }
+    if (messages.length === 0)
+        return [];
+    const gapMs = gapHours * 60 * 60 * 1000;
+    const sessions = [];
+    let currentMessages = [messages[0]];
+    const flush = () => {
+        sessions.push({
+            index: sessions.length,
+            firstMessageAt: currentMessages[0].dateSent,
+            lastMessageAt: currentMessages[currentMessages.length - 1].dateSent,
+            messages: currentMessages,
+        });
+    };
+    for (let i = 1; i < messages.length; i++) {
+        const prevMs = Date.parse(messages[i - 1].dateSent);
+        const currMs = Date.parse(messages[i].dateSent);
+        const gap = currMs - prevMs;
+        if (gap >= gapMs) {
+            flush();
+            currentMessages = [messages[i]];
+        }
+        else {
+            currentMessages.push(messages[i]);
+        }
+    }
+    flush();
+    return sessions;
+}
+//# sourceMappingURL=sessionize.js.map

package/payload/platform/plugins/whatsapp-import/lib/dist/sessionize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionize.js","sourceRoot":"","sources":["../src/sessionize.ts"],"names":[],"mappings":";;AA6CA,gCAmCC;AA/CD;;;;;;;;;;;GAWG;AACH,SAAgB,UAAU,CACxB,QAA+B,EAC/B,QAAgB;IAEhB,IAAI,QAAQ,IAAI,CAAC,EAAE,CAAC;QAClB,MAAM,IAAI,KAAK,CAAC,8CAA8C,QAAQ,EAAE,CAAC,CAAC;IAC5E,CAAC;IACD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAErC,MAAM,KAAK,GAAG,QAAQ,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IACxC,MAAM,QAAQ,GAAc,EAAE,CAAC;IAC/B,IAAI,eAAe,GAAiB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;IAElD,MAAM,KAAK,GAAG,GAAG,EAAE;QACjB,QAAQ,CAAC,IAAI,CAAC;YACZ,KAAK,EAAE,QAAQ,CAAC,MAAM;YACtB,cAAc,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,QAAQ;YAC3C,aAAa,EAAE,eAAe,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,QAAQ;YACnE,QAAQ,EAAE,eAAe;SAC1B,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACzC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;QACpD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;QAChD,MAAM,GAAG,GAAG,MAAM,GAAG,MAAM,CAAC;QAC5B,IAAI,GAAG,IAAI,KAAK,EAAE,CAAC;YACjB,KAAK,EAAE,CAAC;YACR,eAAe,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QAClC,CAAC;aAAM,CAAC;YACN,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACpC,CAAC;IACH,CAAC;IACD,KAAK,EAAE,CAAC;IACR,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/payload/platform/plugins/whatsapp-import/lib/dist/to-classifier-input.d.ts

@@ -0,0 +1,3 @@
+import type { Session } from "./sessionize.js";
+export declare function toClassifierInput(session: Session): string;
+//# sourceMappingURL=to-classifier-input.d.ts.map

package/payload/platform/plugins/whatsapp-import/lib/dist/to-classifier-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-classifier-input.d.ts","sourceRoot":"","sources":["../src/to-classifier-input.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAwB/C,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAM1D"}

package/payload/platform/plugins/whatsapp-import/lib/dist/to-classifier-input.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toClassifierInput = toClassifierInput;
+// ---------------------------------------------------------------------------
+// to-classifier-input — Pass 2 input formatter (Task 891).
+//
+// Pure function. Renders one Session as a turn-attributed text block ready
+// to hand to memory-classify (mode='chat'). Format:
+//
+//   [YYYY-MM-DD HH:MM:SS TZ] <Sender>: <body>
+//   [YYYY-MM-DD HH:MM:SS TZ] <Sender>: <body>
+//   ...
+//
+// Multi-line message bodies are kept verbatim (with their internal newlines).
+// The leading `[ts] <Sender>: ` prefix is the only structural addition; the
+// classifier prompt instructs Haiku to preserve it in the chunk `body` so
+// downstream Phase 2 work can recover per-message provenance via snippet
+// matching against the conversation tail.
+//
+// Timezone: each `dateSent` ISO already carries an offset (set by parseExport
+// from the operator's confirmed IANA zone). The renderer prints the
+// human-readable wall-clock for that offset; the trailing "TZ" suffix is the
+// offset itself, not a zone name.
+// ---------------------------------------------------------------------------
+function toClassifierInput(session) {
+    const lines = [];
+    for (const m of session.messages) {
+        lines.push(`[${formatWallClock(m.dateSent)}] ${m.senderName}: ${m.body}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format an ISO 8601 instant with offset as `YYYY-MM-DD HH:MM:SS ±HH:MM`,
+ * preserving the offset that the parser set from the operator's IANA zone.
+ * The wall-clock components are read directly from the ISO string — no
+ * Date construction (which would re-interpret in the local zone).
+ */
+function formatWallClock(iso) {
+    // ISO from parse-export is shaped: "YYYY-MM-DDTHH:MM:SS±HH:MM" (or "Z").
+    const m = iso.match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(Z|[+-]\d{2}:?\d{2})$/);
+    if (!m)
+        return iso; // surface the raw value if the shape drifted; pure function never throws on caller-supplied data
+    const [, y, mo, d, h, mi, s, off] = m;
+    const offsetLabel = off === "Z" ? "+00:00" : off;
+    return `${y}-${mo}-${d} ${h}:${mi}:${s} ${offsetLabel}`;
+}
+//# sourceMappingURL=to-classifier-input.js.map

package/payload/platform/plugins/whatsapp-import/lib/dist/to-classifier-input.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-classifier-input.js","sourceRoot":"","sources":["../src/to-classifier-input.ts"],"names":[],"mappings":";;AAwBA,8CAMC;AA5BD,8EAA8E;AAC9E,2DAA2D;AAC3D,EAAE;AACF,2EAA2E;AAC3E,oDAAoD;AACpD,EAAE;AACF,8CAA8C;AAC9C,8CAA8C;AAC9C,QAAQ;AACR,EAAE;AACF,8EAA8E;AAC9E,4EAA4E;AAC5E,0EAA0E;AAC1E,yEAAyE;AACzE,0CAA0C;AAC1C,EAAE;AACF,8EAA8E;AAC9E,oEAAoE;AACpE,6EAA6E;AAC7E,kCAAkC;AAClC,8EAA8E;AAE9E,SAAgB,iBAAiB,CAAC,OAAgB;IAChD,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,KAAK,MAAM,CAAC,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;QACjC,KAAK,CAAC,IAAI,CAAC,IAAI,eAAe,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,UAAU,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;IAC5E,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC;AAED;;;;;GAKG;AACH,SAAS,eAAe,CAAC,GAAW;IAClC,yEAAyE;IACzE,MAAM,CAAC,GAAG,GAAG,CAAC,KAAK,CACjB,iFAAiF,CAClF,CAAC;IACF,IAAI,CAAC,CAAC;QAAE,OAAO,GAAG,CAAC,CAAC,iGAAiG;IACrH,MAAM,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;IACtC,MAAM,WAAW,GAAG,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC;IACjD,OAAO,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,WAAW,EAAE,CAAC;AAC1D,CAAC"}

package/payload/platform/scripts/seed-neo4j.sh

@@ -98,22 +98,23 @@ fi
 #                webfetch-preflight.mjs: detects JS-SPA shells before WebFetch's
 #                  60s extraction timeout (Task 536). Fail-open on any error;
 #                  on positive SPA detection exits 2 with WEBFETCH_CANNOT_READ_JS_SPA.
-#                archive-ingest-surface-gate.sh (Task 855; supersedes Task 846):
+#                archive-ingest-surface-gate.sh (Task 855; trimmed by Task 894):
 #                  narrows the database-operator subagent's effective surface
-#                  during WhatsApp archive ingestion to exactly one Bash entry
-#                  (whatsapp-import/bin/whatsapp-ingest.sh) plus read-only
-#                  neighbours, by blocking the legacy MCP deviation tools
-#                  (mcp__memory__whatsapp-export-parse,
-#                  mcp__memory__whatsapp-export-insight-write, and
-#                  mcp__memory__memory-archive-write when archiveType is
-#                  whatsapp-export). Preserves Task 846's plugin-source edit,
-#                  JS test-runner, and post-parse-error blocks (LinkedIn and
-#                  future per-source archive parsers still use the legacy MCP
-#                  path until they migrate to deterministic Bash entries).
+#                  during flat-dataset archive ingestion (LinkedIn today;
+#                  future CRM-type seeds) by enforcing three blocks:
+#                  plugin-source edits under platform/plugins/*/lib/*, JS
+#                  test-runner Bash commands, and a post-parse-error flag
+#                  that blocks the rest of the turn after any
+#                  *-export-parse / *-import-parse tool returns isError=true.
+#                  Task 894 removed the WhatsApp-specific MCP-tool blocks
+#                  (the three legacy whatsapp-export tools were deleted; chat
+#                  archives now flow through the unified document-ingest
+#                  pipeline with parentLabel='ConversationArchive' and
+#                  mode='chat').
 #                  Wired at three points: explicit Edit/Write/NotebookEdit/Bash
-#                  matchers, a no-matcher PreToolUse entry (catches the legacy
-#                  MCP tools and post-parse-error gate fires on every tool),
-#                  and a PostToolUse regex matcher for parse tools.
+#                  matchers, a no-matcher PreToolUse entry (post-parse-error
+#                  gate fires on every tool), and a PostToolUse regex matcher
+#                  for parse tools.
 #                UserPromptSubmit — archive-ingest-surface-gate.sh clears the
 #                  parse-error flag when the operator's next prompt arrives.
 HOOKS_PATH="\$PLATFORM_ROOT/plugins/admin/hooks"