@rubytech/create-realagent 1.0.828 → 1.0.830

package/payload/platform/plugins/{whatsapp-import/bin/ingest.mjs → memory/bin/conversation-archive-ingest.mjs}

@@ -1,38 +1,35 @@
 #!/usr/bin/env node
 // =============================================================================
-// ingest.mjs — in-process orchestrator for whatsapp-ingest.sh (Task 891).
+// conversation-archive-ingest.mjs — in-process orchestrator for
+// conversation-archive-ingest.sh (Task 894 — supersedes whatsapp-import bin).
 //
-// Pipeline (single phase — Phase 2 insight derivation deferred to its own
-// follow-up task):
+// Source-agnostic. The same pipeline runs for every conversation source;
+// `--source <enum>` selects the normaliser at the top of the pipeline:
 //
-//   parse  → bind canonical senders → derive conversationIdentity
+//   normalise  → bind canonical senders → derive conversationIdentity
 //   → look up prior :ConversationArchive (delta cursor)
-//   → sessionize delta at gapHours boundaries
+//   → sessionize delta at gap-hours boundaries
 //   → for each session: classify (mode='chat') → collect chunks
-//   → memoryIngest(parentLabel='ConversationArchive')
+//   → memoryIngest(parentLabel='ConversationArchive', source=<enum>)
 //
 // Argv (positional): <archive-path>
-// Argv (flags):       --owner-element-id <id>
+// Argv (flags):       --source <whatsapp|telegram|signal|linkedin-messages|zoom-transcript|meeting-minutes|imessage|slack|other>
+//                     --owner-element-id <id>
 //                     --participant-person-ids <csv>
 //                     --scope <admin|public>
 //                     [--session-gap-hours <N>]   (default 12)
 //                     [--account-id <accountId>]
 //                     [--timezone <iana>]
 //                     [--date-format <DD/MM/YY|MM/DD/YY|DD/MM/YYYY|MM/DD/YYYY>]
+//                     [--session-id <id>]
 //
-// Owner + participants form the closed sender set; any parsed senderName
-// outside that set LOUD-FAILs with `parser-miss` (preserves Task 887 §A0).
-// `--subject-person-id` and `--filter` are gone (the chunked archive shape
-// makes per-message filtering obsolete — chunking bounds operator surface).
-//
-// Stdout (success): one JSON line — all the counters the skill needs to
-// formulate the three operator-facing messages. See SKILL.md for the shape.
-// Stderr: one [whatsapp-import] FAIL line on failure, exit non-zero.
+// Stdout (success): one JSON line — counters the skill needs to formulate
+// the three operator-facing messages. See SKILL.md for the shape.
+// Stderr: one [conversation-archive] FAIL line on failure, exit non-zero.
 // =============================================================================
 
-import { existsSync, mkdtempSync, readdirSync, rmSync, statSync, createReadStream } from "node:fs";
-import { createHash } from "node:crypto";
-import { join, resolve, dirname, basename } from "node:path";
+import { existsSync, mkdtempSync, readdirSync, rmSync, statSync } from "node:fs";
+import { join, resolve, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
@@ -46,14 +43,25 @@ const platformRoot =
   process.env.MAXY_PLATFORM_ROOT?.trim() ||
   resolve(__dirname, "..", "..", "..");
 
-const PARSE_EXPORT_PATH = resolve(
+const NORMALISERS_PATH = resolve(
   platformRoot,
   "plugins",
-  "whatsapp-import",
-  "lib",
+  "memory",
+  "mcp",
   "dist",
+  "lib",
+  "conversation-normalisers",
   "index.js",
 );
+const PIPELINE_PATH = resolve(
+  platformRoot,
+  "plugins",
+  "memory",
+  "mcp",
+  "dist",
+  "lib",
+  "conversation-pipeline",
+);
 const NEO4J_LIB_PATH = resolve(
   platformRoot,
   "plugins",
@@ -86,7 +94,7 @@ const MEMORY_INGEST_PATH = resolve(
 // 2. Logger
 // ---------------------------------------------------------------------------
 function log(line) {
-  process.stderr.write(`[whatsapp-import] ${line}\n`);
+  process.stderr.write(`[conversation-archive] ${line}\n`);
 }
 function fail(phase, fields) {
   const fieldStr = Object.entries(fields)
@@ -96,13 +104,25 @@ function fail(phase, fields) {
         : `${k}=${v ?? "-"}`,
     )
     .join(" ");
-  process.stderr.write(`[whatsapp-import] FAIL phase=${phase} ${fieldStr}\n`);
+  process.stderr.write(`[conversation-archive] FAIL phase=${phase} ${fieldStr}\n`);
   process.exit(1);
 }
 
 // ---------------------------------------------------------------------------
 // 3. Argv parsing
 // ---------------------------------------------------------------------------
+const VALID_SOURCES = new Set([
+  "whatsapp",
+  "telegram",
+  "signal",
+  "linkedin-messages",
+  "zoom-transcript",
+  "meeting-minutes",
+  "imessage",
+  "slack",
+  "other",
+]);
+
 function parseArgv(argv) {
   const args = argv.slice(2);
   let archive = null;
@@ -120,6 +140,10 @@ function parseArgv(argv) {
     flags[camelCase(key)] = v;
   }
   if (!archive) fail("argv", { reason: "missing positional <archive>" });
+  if (!flags.source) fail("argv", { reason: "missing --source" });
+  if (!VALID_SOURCES.has(flags.source)) {
+    fail("argv", { reason: `invalid --source "${flags.source}" (whatsapp|telegram|signal|linkedin-messages|zoom-transcript|meeting-minutes|imessage|slack|other)` });
+  }
   if (!flags.ownerElementId) fail("argv", { reason: "missing --owner-element-id" });
   if (!flags.participantPersonIds) {
     fail("argv", {
@@ -137,40 +161,45 @@ function camelCase(s) {
 }
 
 // ---------------------------------------------------------------------------
-// 4. Archive resolution
+// 4. Archive resolution. WhatsApp ships zip-or-dir-or-_chat.txt; other
+//    sources pass a single file path that the normaliser interprets directly.
 // ---------------------------------------------------------------------------
-function resolveChatTxt(archivePath) {
+function resolveSourceFile(archivePath, source) {
   const abs = resolve(archivePath);
   if (!existsSync(abs)) fail("argv", { reason: `archive path not found: ${abs}` });
   const st = statSync(abs);
-  if (st.isFile() && abs.endsWith(".zip")) {
-    const tmp = mkdtempSync(join(tmpdir(), "whatsapp-ingest-"));
-    const unzip = spawnSync("unzip", ["-q", "-o", abs, "-d", tmp], { encoding: "utf8" });
-    if (unzip.status !== 0) {
-      rmSync(tmp, { recursive: true });
-      fail("argv", {
-        reason: "unzip failed",
-        archive: abs,
-        stderr: (unzip.stderr || "").slice(0, 200),
-      });
+
+  if (source === "whatsapp") {
+    if (st.isFile() && abs.endsWith(".zip")) {
+      const tmp = mkdtempSync(join(tmpdir(), "conversation-archive-"));
+      const unzip = spawnSync("unzip", ["-q", "-o", abs, "-d", tmp], { encoding: "utf8" });
+      if (unzip.status !== 0) {
+        rmSync(tmp, { recursive: true });
+        fail("argv", {
+          reason: "unzip failed",
+          archive: abs,
+          stderr: (unzip.stderr || "").slice(0, 200),
+        });
+      }
+      const chat = findChatTxt(tmp);
+      if (!chat) {
+        rmSync(tmp, { recursive: true });
+        fail("argv", { reason: "_chat.txt not found in zip", archive: abs });
+      }
+      return { sourceFile: chat, cleanup: () => rmSync(tmp, { recursive: true }) };
     }
-    const chat = findChatTxt(tmp);
-    if (!chat) {
-      rmSync(tmp, { recursive: true });
-      fail("argv", { reason: "_chat.txt not found in zip", archive: abs });
+    if (st.isDirectory()) {
+      const chat = findChatTxt(abs);
+      if (!chat) fail("argv", { reason: "_chat.txt not found in directory", archive: abs });
+      return { sourceFile: chat, cleanup: () => {} };
     }
-    return { chatTxt: chat, cleanup: () => rmSync(tmp, { recursive: true }) };
-  }
-  if (st.isDirectory()) {
-    const chat = findChatTxt(abs);
-    if (!chat) fail("argv", { reason: "_chat.txt not found in directory", archive: abs });
-    return { chatTxt: chat, cleanup: () => {} };
   }
+
   if (st.isFile()) {
-    return { chatTxt: abs, cleanup: () => {} };
+    return { sourceFile: abs, cleanup: () => {} };
   }
-  fail("argv", { reason: `unsupported archive shape: ${abs}` });
-  return { chatTxt: abs, cleanup: () => {} };
+  fail("argv", { reason: `unsupported archive shape for source=${source}: ${abs}` });
+  return { sourceFile: abs, cleanup: () => {} };
 }
 function findChatTxt(dir) {
   const entries = readdirSync(dir, { withFileTypes: true });
@@ -209,121 +238,12 @@ function resolveAccountId(flags) {
 }
 
 // ---------------------------------------------------------------------------
-// 6. Bind canonical sender set (Task 887 §A0 preserved).
-//
-// All distinct parsed senderNames must resolve to {owner, participants...}.
-// Any miss LOUD-FAILs with `parser-miss reason="senderName=<...>"`.
-// ---------------------------------------------------------------------------
-const CANONICAL_FETCH_CYPHER = `
-UNWIND $ids AS id
-MATCH (n) WHERE elementId(n) = id
-RETURN elementId(n) AS elemId,
-       labels(n) AS labels,
-       coalesce(n.name, '') AS name,
-       coalesce(n.givenName, '') AS givenName,
-       coalesce(n.familyName, '') AS familyName,
-       coalesce(n.accountId, '') AS accountId
-`;
-
-class IngestUserFacingError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "IngestUserFacingError";
-    this.userFacing = true;
-  }
-}
-
-async function bindCanonicalSenders({
-  session,
-  accountId,
-  ownerElementId,
-  participantElementIds,
-  senderNames,
-  normaliseSenderName,
-}) {
-  const allIds = [ownerElementId, ...participantElementIds];
-  const distinctIds = Array.from(new Set(allIds));
-  if (distinctIds.length !== allIds.length) {
-    throw new IngestUserFacingError(
-      `participant id list contains duplicates (owner appears in --participant-person-ids?)`,
-    );
-  }
-  const res = await session.executeRead(async (tx) => tx.run(CANONICAL_FETCH_CYPHER, { ids: distinctIds }));
-  const seenIds = new Set();
-  const labelByElemId = new Map();
-  const index = new Map();
-  for (const r of res.records) {
-    const elemId = r.get("elemId");
-    const labels = r.get("labels") || [];
-    const acct = r.get("accountId") || "";
-    if (!acct) {
-      throw new IngestUserFacingError(`node ${elemId} has no accountId — corrupt canonical Person/AdminUser`);
-    }
-    if (acct !== accountId) {
-      throw new IngestUserFacingError(`node ${elemId} belongs to account ${acct}, not ${accountId}`);
-    }
-    if (!labels.includes("Person") && !labels.includes("AdminUser")) {
-      throw new IngestUserFacingError(`node ${elemId} has labels [${labels.join(",")}]; expected :Person or :AdminUser`);
-    }
-    seenIds.add(elemId);
-    labelByElemId.set(elemId, labels.includes("Person") ? "Person" : "AdminUser");
-    const candidates = [];
-    const name = r.get("name") || "";
-    const given = r.get("givenName") || "";
-    const family = r.get("familyName") || "";
-    if (name) candidates.push(name);
-    if (given && family) candidates.push(`${given} ${family}`);
-    if (given) candidates.push(given);
-    if (family) candidates.push(family);
-    for (const c of candidates) {
-      const norm = normaliseSenderName(c);
-      if (!norm) continue;
-      if (!index.has(norm)) index.set(norm, elemId);
-    }
-  }
-  for (const id of distinctIds) {
-    if (!seenIds.has(id)) {
-      throw new IngestUserFacingError(`elementId ${id} not found in graph`);
-    }
-  }
-  // Validate every distinct parsed senderName against the closed candidate set.
-  for (const senderName of senderNames) {
-    const norm = normaliseSenderName(senderName);
-    const hit = index.get(norm);
-    if (!hit) {
-      throw new IngestUserFacingError(
-        `parser-miss reason="senderName=${senderName} not in confirmed participant set (${distinctIds.length} confirmed elementIds; re-run with the missing :Person elementId in --participant-person-ids)"`,
-      );
-    }
-  }
-  return { participantsResolved: seenIds.size };
-}
-
-// ---------------------------------------------------------------------------
-// 7. SHA-256 of file bytes (for archiveSha256)
-// ---------------------------------------------------------------------------
-async function fileSha256(filePath) {
-  return new Promise((resolveProm, rejectProm) => {
-    const hash = createHash("sha256");
-    const stream = createReadStream(filePath);
-    stream.on("data", (chunk) => hash.update(chunk));
-    stream.on("end", () => resolveProm(hash.digest("hex")));
-    stream.on("error", rejectProm);
-  });
-}
-
-// ---------------------------------------------------------------------------
-// 8. Build natural-edge map for chat-mode classifier.
-// Chat mode doesn't use it (the chat prompt drops edge proposals), but
-// classifyDocument's signature still takes the param. Pass the empty string.
-// ---------------------------------------------------------------------------
-
-// ---------------------------------------------------------------------------
-// 9. Main
+// 6. Main
 // ---------------------------------------------------------------------------
 async function main() {
   const startedMs = Date.now();
   const { archive, flags } = parseArgv(process.argv);
+  const source = flags.source;
   const ownerElementId = flags.ownerElementId;
   const participantElementIds = flags.participantPersonIds
     .split(",")
@@ -343,22 +263,23 @@ async function main() {
     fail("argv", { reason: `invalid --session-gap-hours "${flags.sessionGapHours}" (must be positive number)` });
   }
   const sessionId =
-    flags.sessionId || `whatsapp-import:${Date.now()}:${Math.random().toString(36).slice(2, 10)}`;
+    flags.sessionId ||
+    `conversation-archive:${source}:${Date.now()}:${Math.random().toString(36).slice(2, 10)}`;
 
   // Imports — fail loudly if any compiled dist missing
-  let parseExport, sessionize, toClassifierInput, findDeltaCursor;
+  let getNormaliser;
+  let sessionize, toTurnText, findDeltaCursor;
   let normaliseSenderName, deriveConversationIdentity, deriveMessageContentHash;
+  let bindCanonicalSenders;
   let getSession, classifyDocument, memoryIngest;
   try {
-    ({
-      parseExport,
-      sessionize,
-      toClassifierInput,
-      findDeltaCursor,
-      normaliseSenderName,
-      deriveConversationIdentity,
-      deriveMessageContentHash,
-    } = await import(PARSE_EXPORT_PATH));
+    ({ getNormaliser } = await import(NORMALISERS_PATH));
+    ({ sessionize } = await import(join(PIPELINE_PATH, "sessionize.js")));
+    ({ toTurnText } = await import(join(PIPELINE_PATH, "to-turn-text.js")));
+    ({ findDeltaCursor } = await import(join(PIPELINE_PATH, "delta-cursor.js")));
+    ({ normaliseSenderName, deriveConversationIdentity, deriveMessageContentHash } =
+      await import(join(PIPELINE_PATH, "derive-keys.js")));
+    ({ bindCanonicalSenders } = await import(join(PIPELINE_PATH, "sender-bind.js")));
     ({ getSession } = await import(NEO4J_LIB_PATH));
     ({ classifyDocument } = await import(LLM_CLASSIFIER_PATH));
     ({ memoryIngest } = await import(MEMORY_INGEST_PATH));
@@ -369,32 +290,38 @@ async function main() {
     });
   }
 
-  // 9a. Resolve _chat.txt + sha256
-  const { chatTxt, cleanup } = resolveChatTxt(archive);
-  const archiveSha256 = await fileSha256(chatTxt);
-  const archiveSourceFile = basename(chatTxt);
-  log(
-    `start file=${archiveSourceFile} owner=${ownerElementId} participants=${participantElementIds.length} scope=${scope} accountId=${accountId} archiveSha256=${archiveSha256.slice(0, 12)} session-gap-hours=${sessionGapHours}`,
-  );
+  // 6a. Resolve source file
+  const { sourceFile, cleanup } = resolveSourceFile(archive, source);
 
-  // 9b. Parse
-  let parseResult;
+  // 6b. Run the source-specific normaliser
+  let normaliserResult;
   try {
-    parseResult = parseExport({ filePath: chatTxt, accountId, timezone, dateFormat });
+    const normaliser = getNormaliser(source);
+    normaliserResult = await normaliser({
+      filePath: sourceFile,
+      accountId,
+      timezone,
+      opts: dateFormat ? { dateFormat } : undefined,
+    });
   } catch (err) {
     cleanup();
     fail("parse", { reason: err instanceof Error ? err.message : String(err) });
   }
-  const allLines = parseResult.parsedLines;
+  const allLines = normaliserResult.parsedLines;
+  const archiveSha256 = normaliserResult.archiveSha256;
+  const archiveSourceFile = normaliserResult.archiveSourceFile;
+  log(
+    `source=${source} file=${archiveSourceFile} owner=${ownerElementId} participants=${participantElementIds.length} scope=${scope} accountId=${accountId} archiveSha256=${archiveSha256.slice(0, 12)} session-gap-hours=${sessionGapHours}`,
+  );
   log(
-    `parsed lines=${parseResult.counters.parsed} media-skipped=${parseResult.counters.mediaSkipped} system-skipped=${parseResult.counters.systemSkipped}`,
+    `parsed lines=${normaliserResult.counters.parsed} media-skipped=${normaliserResult.counters.mediaSkipped} system-skipped=${normaliserResult.counters.systemSkipped}`,
   );
   if (allLines.length === 0) {
     cleanup();
     fail("parse", { reason: "zero parsed lines after walking archive" });
   }
 
-  // 9c. Bind canonical senders against the confirmed set
+  // 6c. Bind canonical senders against the confirmed set
   const distinctSenderNames = Array.from(new Set(allLines.map((l) => l.senderName)));
   const senderHistogram = computeSenderHistogram(allLines);
   let session = getSession();
@@ -405,19 +332,18 @@ async function main() {
       ownerElementId,
       participantElementIds,
       senderNames: distinctSenderNames,
-      normaliseSenderName,
     });
   } catch (err) {
     await session.close().catch(() => {});
     cleanup();
     if (err && err.userFacing) {
-      process.stderr.write(`[whatsapp-import] FAIL ${err.message}\n`);
+      process.stderr.write(`[conversation-archive] FAIL ${err.message}\n`);
       process.exit(1);
     }
     fail("argv", { reason: err instanceof Error ? err.message : String(err) });
   }
 
-  // 9d. Derive conversationIdentity and look up prior :ConversationArchive
+  // 6d. Derive conversationIdentity and look up prior :ConversationArchive
   const conversationIdentity = deriveConversationIdentity({
     accountId,
     participantElementIds: [ownerElementId, ...participantElementIds],
@@ -445,7 +371,7 @@ async function main() {
   }
   await session.close().catch(() => {});
 
-  // 9e. Compute deltaStart
+  // 6e. Compute deltaStart
   let deltaStart = 0;
   let deltaKind = "first-ingest";
   if (priorArchive && priorArchive.lastHash) {
@@ -467,9 +393,10 @@ async function main() {
         conversationIdentity,
         archiveSha256,
         archiveSourceFile,
-        parsed: parseResult.counters.parsed,
-        mediaSkipped: parseResult.counters.mediaSkipped,
-        systemSkipped: parseResult.counters.systemSkipped,
+        source,
+        parsed: normaliserResult.counters.parsed,
+        mediaSkipped: normaliserResult.counters.mediaSkipped,
+        systemSkipped: normaliserResult.counters.systemSkipped,
         delta: { kind: "empty-delta", deltaStart: allLines.length, deltaMessages: 0 },
         sessions: 0,
         chunks: 0,
@@ -491,22 +418,22 @@ async function main() {
     `delta cursor=${priorArchive ? priorArchive.lastHash.slice(0, 12) : "(first-ingest)"} cursor-line=${deltaStart} delta-messages=${deltaLines.length}`,
   );
 
-  // 9f. Sessionize delta
+  // 6f. Sessionize delta
   const sessions = sessionize(deltaLines, sessionGapHours);
   log(
-    `sessionize file=${archiveSourceFile} archiveSha256=${archiveSha256.slice(0, 12)} messages=${deltaLines.length} sessions=${sessions.length} gap-hours=${sessionGapHours}`,
+    `sessionize source=${source} archiveSha256=${archiveSha256.slice(0, 12)} messages=${deltaLines.length} sessions=${sessions.length} gap-hours=${sessionGapHours}`,
   );
 
-  // 9g. Classify each session via Haiku (mode='chat')
+  // 6g. Classify each session via Haiku (mode='chat')
   const allChunks = [];
   const allKeywords = new Set();
   for (const s of sessions) {
     const sessionStart = Date.now();
-    const text = toClassifierInput(s);
+    const text = toTurnText(s);
     const result = await classifyDocument({
       accountId,
       mode: "chat",
-      anchorDescription: `WhatsApp conversation between ${[ownerElementId, ...participantElementIds].length} participants (session ${s.index + 1} of ${sessions.length})`,
+      anchorDescription: `Conversation transcript (${[ownerElementId, ...participantElementIds].length} participants, session ${s.index + 1} of ${sessions.length})`,
       ontologyLabels: new Set([]),
       naturalEdgeMap: "",
       documentText: text,
@@ -525,15 +452,11 @@ async function main() {
         reason: `session ${s.index} of ${s.messages.length} messages produced zero chunks (classifier-prompt regression)`,
       });
     }
-    for (const sec of result.output.sections) {
-      allChunks.push(sec);
-    }
-    for (const kw of result.output.documentKeywords) {
-      allKeywords.add(kw);
-    }
+    for (const sec of result.output.sections) allChunks.push(sec);
+    for (const kw of result.output.documentKeywords) allKeywords.add(kw);
   }
 
-  // 9h. Compute lastIngestedMessageHash from the last delta line
+  // 6h. Compute lastIngestedMessageHash from the last delta line
   const lastLine = deltaLines[deltaLines.length - 1];
   const lastIngestedMessageHash = deriveMessageContentHash({
     dateSent: lastLine.dateSent,
@@ -542,23 +465,23 @@ async function main() {
   });
   const lastIngestedMessageAt = lastLine.dateSent;
 
-  // 9i. Aggregate document-level summary across sessions (concatenate first
-  //     two-three classifier summaries; the parent's summary is informational)
+  // 6i. Aggregate document-level summary across sessions
   const documentSummary = sessions.length === 1
     ? `${deltaLines.length} messages in 1 session, ${allChunks.length} chunks.`
     : `${deltaLines.length} messages in ${sessions.length} sessions, ${allChunks.length} chunks.`;
 
-  // 9j. Call memoryIngest with parentLabel='ConversationArchive'
+  // 6j. Call memoryIngest with parentLabel='ConversationArchive'
   let ingestResult;
   const ingestStart = Date.now();
   try {
     ingestResult = await memoryIngest({
       accountId,
-      attachmentId: conversationIdentity, // semantic rename per parentLabel
+      attachmentId: conversationIdentity,
       parentLabel: "ConversationArchive",
+      source,
       documentSummary,
       anchorNodeId: ownerElementId,
-      anchorLabel: "AdminUser", // unused in chat path but required by IngestParams
+      anchorLabel: "AdminUser",
       sections: allChunks,
       scope,
       sessionId,
@@ -574,21 +497,22 @@ async function main() {
     fail("memory-ingest", { reason: err instanceof Error ? err.message : String(err) });
   }
   log(
-    `file=${archiveSourceFile} conversationIdentity=${conversationIdentity.slice(0, 12)} archiveElementId=${ingestResult.documentNodeId} chunks-written=${ingestResult.sectionCount} next-edges=${ingestResult.edgeBreakdown.NEXT ?? 0} participants=${ingestResult.edgeBreakdown.PARTICIPANT_IN ?? 0} ms=${Date.now() - ingestStart}`,
+    `source=${source} file=${archiveSourceFile} conversationIdentity=${conversationIdentity.slice(0, 12)} archiveElementId=${ingestResult.documentNodeId} chunks-written=${ingestResult.sectionCount} next-edges=${ingestResult.edgeBreakdown.NEXT ?? 0} participants=${ingestResult.edgeBreakdown.PARTICIPANT_IN ?? 0} ms=${Date.now() - ingestStart}`,
   );
 
   cleanup();
   const totalMs = Date.now() - startedMs;
-  log(`done conversationIdentity=${conversationIdentity.slice(0, 12)} total-ms=${totalMs} exit=0`);
+  log(`done source=${source} conversationIdentity=${conversationIdentity.slice(0, 12)} total-ms=${totalMs} exit=0`);
 
   process.stdout.write(JSON.stringify({
     archiveElementId: ingestResult.documentNodeId,
     conversationIdentity,
     archiveSha256,
     archiveSourceFile,
-    parsed: parseResult.counters.parsed,
-    mediaSkipped: parseResult.counters.mediaSkipped,
-    systemSkipped: parseResult.counters.systemSkipped,
+    source,
+    parsed: normaliserResult.counters.parsed,
+    mediaSkipped: normaliserResult.counters.mediaSkipped,
+    systemSkipped: normaliserResult.counters.systemSkipped,
     delta: { kind: deltaKind, deltaStart, deltaMessages: deltaLines.length },
     sessions: sessions.length,
     chunks: ingestResult.sectionCount,

package/payload/platform/plugins/{whatsapp-import/bin/whatsapp-ingest.sh → memory/bin/conversation-archive-ingest.sh}

@@ -1,49 +1,55 @@
 #!/usr/bin/env bash
 # =============================================================================
-# whatsapp-ingest.sh — single deterministic Bash entry for WhatsApp archive
-# ingestion (Task 891 — chunked :ConversationArchive shape).
+# conversation-archive-ingest.sh — single deterministic Bash entry for
+# conversation-archive ingestion (Task 894 — supersedes whatsapp-ingest.sh).
 #
-# Pipeline: parse → bind canonical sender set → derive conversationIdentity →
-# look up prior :ConversationArchive (delta cursor) → sessionize delta at
-# gap-hours boundary → classify each session via Haiku (mode='chat') →
-# memory-ingest with parentLabel='ConversationArchive'.
+# Source-agnostic: WhatsApp `_chat.txt`, Telegram, Signal, LinkedIn DMs, Zoom
+# transcript, meeting minutes, iMessage, Slack — every source flows through
+# the same pipeline with `--source` selecting the normaliser.
+#
+# Pipeline: normalise (per source) → bind canonical sender set →
+# derive conversationIdentity → look up prior :ConversationArchive (delta
+# cursor) → sessionize delta at gap-hours boundary → classify each session
+# via Haiku (mode='chat') → memory-ingest with parentLabel='ConversationArchive'.
 #
 # Usage:
-#   bash whatsapp-ingest.sh <archive.zip|dir|_chat.txt>
+#   bash conversation-archive-ingest.sh <archive-path>
+#         --source <whatsapp|telegram|signal|linkedin-messages|zoom-transcript|meeting-minutes|imessage|slack|other>
 #         --owner-element-id <id>
 #         --participant-person-ids <csv>
 #         --scope <admin|public>
 #         [--session-gap-hours <N>]    (default 12)
 #         [--account-id <accountId>]
 #         [--timezone <iana-zone>]
-#         [--date-format <DD/MM/YY|MM/DD/YY|DD/MM/YYYY|MM/DD/YYYY>]
+#         [--date-format <DD/MM/YY|MM/DD/YY|DD/MM/YYYY|MM/DD/YYYY>]   (whatsapp only)
 #
 # `--owner-element-id` + `--participant-person-ids` form the closed sender
 # set; any parsed senderName outside that set LOUD-FAILs with `parser-miss`
-# and exits non-zero. `--filter` and `--subject-person-id` are gone — chunked
-# Section:Conversation rows bound the operator surface naturally.
+# and exits non-zero.
 #
 # Exit 0  + JSON summary on stdout on success.
-# Exit !0 + one [whatsapp-import] FAIL line on stderr on failure.
+# Exit !0 + one [conversation-archive] FAIL line on stderr on failure.
 # =============================================================================
 
 set -euo pipefail
 
 arg_fail() {
   local reason="$1"
-  echo "[whatsapp-import] FAIL phase=argv reason=\"${reason}\"" >&2
+  echo "[conversation-archive] FAIL phase=argv reason=\"${reason}\"" >&2
   exit 1
 }
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PLATFORM_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-INGEST_MJS="$SCRIPT_DIR/ingest.mjs"
+INGEST_MJS="$SCRIPT_DIR/conversation-archive-ingest.mjs"
 
 if [ ! -f "$INGEST_MJS" ]; then
-  arg_fail "ingest.mjs not found at $INGEST_MJS — run from a built install"
+  arg_fail "conversation-archive-ingest.mjs not found at $INGEST_MJS — run from a built install"
 fi
 
 ARCHIVE=""
+HAS_SOURCE=0
+SOURCE_VAL=""
 HAS_OWNER=0
 OWNER_VAL=""
 HAS_PARTICIPANTS=0
@@ -56,10 +62,11 @@ i=0
 while [ $i -lt ${#ARGS[@]} ]; do
   a="${ARGS[$i]}"
   case "$a" in
+    --source)                  HAS_SOURCE=1;       SOURCE_VAL="${ARGS[$((i + 1))]:-}";       i=$((i + 2)); continue ;;
     --owner-element-id)        HAS_OWNER=1;        OWNER_VAL="${ARGS[$((i + 1))]:-}";        i=$((i + 2)); continue ;;
     --participant-person-ids)  HAS_PARTICIPANTS=1; PARTICIPANTS_VAL="${ARGS[$((i + 1))]:-}"; i=$((i + 2)); continue ;;
     --scope)                   HAS_SCOPE=1;        SCOPE_VAL="${ARGS[$((i + 1))]:-}";        i=$((i + 2)); continue ;;
-    --session-gap-hours|--account-id|--timezone|--date-format) i=$((i + 2)); continue ;;
+    --session-gap-hours|--account-id|--timezone|--date-format|--session-id) i=$((i + 2)); continue ;;
     --*)                       i=$((i + 2)); continue ;;
     *)
       if [ -z "$ARCHIVE" ]; then ARCHIVE="$a"; fi
@@ -69,10 +76,11 @@ while [ $i -lt ${#ARGS[@]} ]; do
   esac
 done
 
-[ -n "$ARCHIVE" ]                                              || arg_fail "missing positional <archive>"
-[ "$HAS_OWNER"        -eq 1 ] && [ -n "$OWNER_VAL"        ]    || arg_fail "missing --owner-element-id (or empty value)"
-[ "$HAS_PARTICIPANTS" -eq 1 ] && [ -n "$PARTICIPANTS_VAL" ]    || arg_fail "missing --participant-person-ids (csv of operator-confirmed :Person/:AdminUser elementIds, owner excluded)"
-[ "$HAS_SCOPE"        -eq 1 ] && [ -n "$SCOPE_VAL"        ]    || arg_fail "missing --scope (or empty value)"
+[ -n "$ARCHIVE" ]                                                || arg_fail "missing positional <archive>"
+[ "$HAS_SOURCE"       -eq 1 ] && [ -n "$SOURCE_VAL"       ]      || arg_fail "missing --source (whatsapp|telegram|signal|linkedin-messages|zoom-transcript|meeting-minutes|imessage|slack|other)"
+[ "$HAS_OWNER"        -eq 1 ] && [ -n "$OWNER_VAL"        ]      || arg_fail "missing --owner-element-id (or empty value)"
+[ "$HAS_PARTICIPANTS" -eq 1 ] && [ -n "$PARTICIPANTS_VAL" ]      || arg_fail "missing --participant-person-ids (csv of operator-confirmed :Person/:AdminUser elementIds, owner excluded)"
+[ "$HAS_SCOPE"        -eq 1 ] && [ -n "$SCOPE_VAL"        ]      || arg_fail "missing --scope (or empty value)"
 case "$SCOPE_VAL" in
   admin|public) : ;;
   *) arg_fail "invalid --scope \"$SCOPE_VAL\" (admin|public)" ;;