@rubytech/create-realagent 1.0.826 → 1.0.829

package/payload/platform/plugins/whatsapp-import/bin/ingest.mjs

@@ -1,670 +0,0 @@
-#!/usr/bin/env node
-// =============================================================================
-// ingest.mjs — in-process orchestrator for whatsapp-ingest.sh.
-//
-// Phase 1 of the two-phase WhatsApp ingest contract (Task 855 / Task 871).
-// Deterministic only: parse → operator-supplied filter → archive-write
-// (Conversation + Messages + auto-Person participants + NEXT chronology).
-// No LLM in the per-message decision path. The Haiku insight pass moved to
-// Phase 2 (`mcp__memory__whatsapp-export-insight-pass`), invoked consciously
-// by the operator via the `whatsapp-import-enrich` skill.
-//
-// Argv (positional): <archive-path>
-// Argv (flags):       --owner-element-id <id> --scope <admin|public>
-//                     --subject-person-id <id>
-//                     --filter <all|senders=<csv>|date-range=<isoFrom>..<isoTo>>
-//                     [--account-id <accountId>] [--timezone <iana>]
-//                     [--date-format <DD/MM/YY|MM/DD/YY|DD/MM/YYYY|MM/DD/YYYY>]
-//
-// Task 887 §A0 — `--subject-person-id` is required. DM scope: the operator
-// confirms the third party's :Person elementId from the preview histogram
-// before invoking. The writer accepts EXACTLY the senderNames carried by
-// {owner, subject}; any parsed senderName outside that set LOUD-FAILs with
-// `parser-miss reason="senderName=<verbatim> not in preview histogram
-// (parser failure — re-export or report)"`. Bounds writer cardinality to
-// the deterministic preview output — closes the auto-Person leak structurally.
-//
-// Stdout (success): one JSON line — Honest counters per Task 871.5.
-//   {conversationElementId, conversationId,
-//    parsed, mediaSkipped, systemSkipped,
-//    filtered,
-//    written, messagesAlreadyExisted,
-//    nextEdgesProcessed, nextEdgesCreated,
-//    participantsAlreadyExisted,
-//    ms}
-// The skill (`whatsapp-import` SKILL.md) maps this verbose-diagnostic shape
-// to the agent-return short shape per Task 871.6 (`alreadyExisted` etc.)
-// when surfacing the result to the admin agent.
-//
-// Stderr (failure): one [whatsapp-ingest] FAIL line, exit non-zero.
-// =============================================================================
-
-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";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-// ---------------------------------------------------------------------------
-// 1. Resolve dist paths from the platform install root.
-// ---------------------------------------------------------------------------
-// MAXY_PLATFORM_ROOT is set by the wrapper script (and by claude-agent.ts in
-// production). Fall back to walking up from this file's location: the bin/
-// directory sits at platform/plugins/whatsapp-import/bin/, so platform/ is
-// three levels up.
-
-const platformRoot =
-  process.env.MAXY_PLATFORM_ROOT?.trim() ||
-  resolve(__dirname, "..", "..", "..");
-
-const PARSE_EXPORT_PATH = resolve(
-  platformRoot,
-  "plugins",
-  "whatsapp-import",
-  "lib",
-  "dist",
-  "index.js",
-);
-const ARCHIVE_WRITE_PATH = resolve(
-  platformRoot,
-  "plugins",
-  "memory",
-  "mcp",
-  "dist",
-  "tools",
-  "memory-archive-write.js",
-);
-const NEO4J_LIB_PATH = resolve(
-  platformRoot,
-  "plugins",
-  "memory",
-  "mcp",
-  "dist",
-  "lib",
-  "neo4j.js",
-);
-// Task 870: pure key-derivation functions ship in the whatsapp-import lib.
-const DERIVE_KEYS_PATH = resolve(
-  platformRoot,
-  "plugins",
-  "whatsapp-import",
-  "lib",
-  "dist",
-  "derive-keys.js",
-);
-
-// ---------------------------------------------------------------------------
-// 2. Logger — every line `[whatsapp-ingest]`-prefixed to stderr (server.log).
-// ---------------------------------------------------------------------------
-
-function log(line) {
-  process.stderr.write(`[whatsapp-ingest] ${line}\n`);
-}
-
-function fail(phase, fields) {
-  // Single failure line. Used as the only stderr line on non-zero exit.
-  const fieldStr = Object.entries(fields)
-    .map(([k, v]) =>
-      typeof v === "string" && (v.includes(" ") || v.includes("="))
-        ? `${k}="${v.replace(/"/g, '\\"')}"`
-        : `${k}=${v ?? "-"}`,
-    )
-    .join(" ");
-  process.stderr.write(`[whatsapp-ingest] FAIL phase=${phase} ${fieldStr}\n`);
-  process.exit(1);
-}
-
-// ---------------------------------------------------------------------------
-// 3. Argv parsing.
-// ---------------------------------------------------------------------------
-
-function parseArgv(argv) {
-  const args = argv.slice(2);
-  let archive = null;
-  const flags = {};
-  for (let i = 0; i < args.length; i++) {
-    const a = args[i];
-    if (!a.startsWith("--")) {
-      if (archive == null) archive = a;
-      else fail("argv", { reason: `unexpected positional argument "${a}"` });
-      continue;
-    }
-    const key = a.slice(2);
-    const v = args[++i];
-    if (v == null) fail("argv", { reason: `flag --${key} requires a value` });
-    flags[camelCase(key)] = v;
-  }
-  if (!archive) fail("argv", { reason: "missing positional <archive>" });
-  if (!flags.ownerElementId) fail("argv", { reason: "missing --owner-element-id" });
-  if (!flags.scope) fail("argv", { reason: "missing --scope" });
-  if (flags.scope !== "admin" && flags.scope !== "public") {
-    fail("argv", { reason: `invalid --scope "${flags.scope}" (admin|public)` });
-  }
-  // Task 887 §A0 — DM scope: a single `--subject-person-id` identifies the
-  // third party in the conversation. The owner + subject pair is the
-  // canonical sender set; the writer rejects any other senderName as
-  // parser-miss. Group-chat ingest (>2 distinct senders) is a future task.
-  if (!flags.subjectPersonId) {
-    fail("argv", { reason: "missing --subject-person-id (Task 887: operator-confirmed third-party :Person elementId from preview histogram)" });
-  }
-  // Task 871: --filter is mandatory. The deterministic Bash entry refuses
-  // bulk archive writes without an operator-supplied filter — closes the
-  // doctrine gap named in feedback_compress_at_ingest_for_bulk_archives.md.
-  if (!flags.filter || !flags.filter.trim()) {
-    process.stderr.write(
-      `[whatsapp-ingest] FAIL filter-required reason="bulk-archive-gate (Task 871) — operator must specify --filter (one of all, senders=<csv>, date-range=<isoFrom>..<isoTo>)"\n`,
-    );
-    fail("argv", { reason: "--filter is required (one of all, senders=<csv>, date-range=<isoFrom>..<isoTo>)" });
-  }
-  return { archive, flags };
-}
-
-function camelCase(s) {
-  return s.replace(/-([a-z])/g, (_m, c) => c.toUpperCase());
-}
-
-// ---------------------------------------------------------------------------
-// 4. Archive resolution — accept .zip / dir / _chat.txt; return absolute
-//    path to _chat.txt and a cleanup callback for any tmp dir we created.
-// ---------------------------------------------------------------------------
-
-function resolveChatTxt(archivePath) {
-  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, force: true });
-      fail("argv", {
-        reason: "unzip failed",
-        archive: abs,
-        stderr: (unzip.stderr || "").slice(0, 200),
-      });
-    }
-    const chat = findChatTxt(tmp);
-    if (!chat) {
-      rmSync(tmp, { recursive: true, force: true });
-      fail("argv", { reason: "_chat.txt not found in zip", archive: abs });
-    }
-    return { chatTxt: chat, cleanup: () => rmSync(tmp, { recursive: true, force: 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: () => {} };
-  }
-
-  fail("argv", { reason: `unsupported archive shape: ${abs}` });
-  // unreachable, but keeps tools happy
-  return { chatTxt: abs, cleanup: () => {} };
-}
-
-function findChatTxt(dir) {
-  const entries = readdirSync(dir, { withFileTypes: true });
-  for (const e of entries) {
-    if (e.isFile() && e.name === "_chat.txt") return join(dir, e.name);
-  }
-  for (const e of entries) {
-    if (e.isDirectory()) {
-      const nested = findChatTxt(join(dir, e.name));
-      if (nested) return nested;
-    }
-  }
-  return null;
-}
-
-// ---------------------------------------------------------------------------
-// 5. Account resolution — Phase 0 has one account dir. The wrapper passes
-//    --account-id when it is known; otherwise we pick the single dir under
-//    {install}/data/accounts/.
-// ---------------------------------------------------------------------------
-
-function resolveAccountId(flags) {
-  if (flags.accountId && flags.accountId.trim()) return flags.accountId.trim();
-  const installDir = resolve(platformRoot, "..");
-  const accountsDir = join(installDir, "data", "accounts");
-  if (!existsSync(accountsDir)) {
-    fail("argv", {
-      reason: `accounts dir not found: ${accountsDir}; pass --account-id explicitly`,
-    });
-  }
-  const dirs = readdirSync(accountsDir, { withFileTypes: true })
-    .filter((d) => d.isDirectory() && !d.name.startsWith("."))
-    .map((d) => d.name);
-  if (dirs.length === 0) {
-    fail("argv", { reason: `no accounts found under ${accountsDir}` });
-  }
-  if (dirs.length > 1) {
-    fail("argv", {
-      reason: `multiple accounts under ${accountsDir} (${dirs.join(",")}); pass --account-id explicitly`,
-    });
-  }
-  return dirs[0];
-}
-
-// ---------------------------------------------------------------------------
-// 6. Bind senders to canonical {owner, subject} pair (Task 887 §A0).
-//
-// Pre-887 behaviour: a `resolveParticipants` step ran each parsed senderName
-// against an account-wide canonical index, falling through to auto-create a
-// `:Person {participantStatus:'auto-created'}` node for any miss. That
-// fallback path was the structural defect: any parser failure that produced
-// a polluted senderName (Task 845's LRM-prefixed body glued onto the prior
-// header → senderName="\"Adam Mackay:\\n‎[04/02/2026, 11:52:16] Adam Mackay\"")
-// leaked one bogus :Person per distinct miss. 23 leaked from the Adam Mackay
-// archive in a single ingest.
-//
-// 887 §A0 closes the leak by deleting the fallback. The operator now passes
-// `--subject-person-id` (third-party Person elementId from preview), the
-// dispatch passes `--owner-element-id`, and the writer accepts EXACTLY the
-// name candidates of those two nodes. Any parsed senderName outside that
-// closed set LOUD-FAILs the ingest with the verbatim string — surfacing a
-// parser bug as a hard exit instead of as graph pollution.
-// ---------------------------------------------------------------------------
-
-const CANONICAL_PAIR_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
-`;
-
-/**
- * Sentinel error class so `main()`'s try/catch can recognise an operator
- * LOUD-FAIL (already-emitted FAIL line) and exit cleanly with cleanup.
- * Plain `process.exit(1)` from inside `bindCanonicalSenders` would skip
- * `main()`'s `cleanup()` (unzip tmp dir) and `session.close()` paths.
- */
-class IngestUserFacingError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "IngestUserFacingError";
-    this.userFacing = true;
-  }
-}
-
-async function bindCanonicalSenders({
-  session,
-  accountId,
-  ownerElementId,
-  subjectPersonId,
-  senderNames,
-  normaliseSenderName,
-}) {
-  // Distinctness pre-flight — operator passing the same id for both flags
-  // collapses to a single bound participant; the drift between
-  // `participantCount=2` (from distinct senderNames) and
-  // `participantsAlreadyExisted=1` would propagate to the JSON summary
-  // silently. Refuse early, name the cause.
-  if (ownerElementId === subjectPersonId) {
-    throw new IngestUserFacingError(
-      `--owner-element-id and --subject-person-id must be distinct elementIds (both supplied as "${ownerElementId}")`,
-    );
-  }
-
-  const ids = [ownerElementId, subjectPersonId];
-  const res = await session.executeRead(async (tx) =>
-    tx.run(CANONICAL_PAIR_FETCH_CYPHER, { ids }),
-  );
-
-  // Build normalised-name → elementId index from owner + subject candidates.
-  // For each node we accept the full name, given name, family name, and
-  // "given family" composite as match candidates so an export header that
-  // says "Adam" or "Adam Mackay" both resolve to the same node.
-  const index = new Map();
-  const seenIds = new Set();
-  const labelByElemId = new Map();
-  for (const r of res.records) {
-    const elemId = r.get("elemId");
-    const labels = r.get("labels") || [];
-    const acct = r.get("accountId") || "";
-    // Empty accountId on a canonical Person/AdminUser is a graph-data
-    // defect (migration 004 normally prunes account-less nodes). Refuse
-    // rather than silently accept — bound-pair correctness depends on
-    // accountId being present and matching.
-    if (!acct) {
-      throw new IngestUserFacingError(
-        `node ${elemId} has no accountId — corrupt canonical Person/AdminUser; refusing ingest`,
-      );
-    }
-    if (acct !== accountId) {
-      throw new IngestUserFacingError(
-        `node ${elemId} belongs to account ${acct}, not ${accountId} — refusing cross-account ingest`,
-      );
-    }
-    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);
-    }
-  }
-
-  // Both ids must resolve. A typo'd or stale id is operator error; LOUD-FAIL
-  // before any parser work touches the graph.
-  if (!seenIds.has(ownerElementId)) {
-    throw new IngestUserFacingError(
-      `--owner-element-id ${ownerElementId} not found in graph`,
-    );
-  }
-  if (!seenIds.has(subjectPersonId)) {
-    throw new IngestUserFacingError(
-      `--subject-person-id ${subjectPersonId} not found in graph`,
-    );
-  }
-  // Subject must specifically be a `:Person` — the third party in a DM is
-  // never the operator's `:AdminUser`. (Owner can be either; both Adam and
-  // an external collaborator owning an export are operator-curated cases.)
-  if (labelByElemId.get(subjectPersonId) !== "Person") {
-    throw new IngestUserFacingError(
-      `--subject-person-id ${subjectPersonId} resolves to a :${labelByElemId.get(subjectPersonId)} — subject must be a :Person`,
-    );
-  }
-
-  // Group-chat early-detect: the singular `--subject-person-id` flag is
-  // DM-scoped. A `_chat.txt` carrying ≥3 distinct senders is an unsupported
-  // scope, NOT a parser bug. Emit a distinct reason so the operator does
-  // not chase a phantom parser regression. Group-chat support is the
-  // separate Task 889 lane.
-  if (senderNames.length > 2) {
-    throw new IngestUserFacingError(
-      `unsupported-scope reason="archive carries ${senderNames.length} distinct senders; --subject-person-id is DM-only (≤2 senders) — group-chat ingest is the separate Task 889 lane"`,
-    );
-  }
-
-  // Validate every distinct parsed senderName against the closed candidate
-  // set. The first miss is the LOUD-FAIL — operators see one parser-miss
-  // line per bad import, not 23.
-  const idsByName = new Map();
-  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 preview histogram (parser failure — re-export or report)"`,
-      );
-    }
-    idsByName.set(senderName, hit);
-    log(
-      `participant-resolved senderName="${senderName}" matched=canonical nodeId=${hit}`,
-    );
-  }
-  // participantsAlreadyExisted = always 2 (owner + subject) under the
-  // bound-pair contract; expose it for the JSON summary's existing field.
-  return { idsByName, participantsAlreadyExisted: seenIds.size };
-}
-
-// ---------------------------------------------------------------------------
-// 7. Main.
-// ---------------------------------------------------------------------------
-
-async function main() {
-  const startedMs = Date.now();
-  const { archive, flags } = parseArgv(process.argv);
-  const ownerElementId = flags.ownerElementId;
-  const subjectPersonId = flags.subjectPersonId;
-  const scope = flags.scope;
-  const accountId = resolveAccountId(flags);
-  const timezone = flags.timezone || "Europe/London";
-  const dateFormat = flags.dateFormat;
-  const sessionId =
-    flags.sessionId || `whatsapp-ingest:${Date.now()}:${Math.random().toString(36).slice(2, 10)}`;
-
-  let parseExport, parseFilterArg, applyFilter, memoryArchiveWrite, getSession;
-  let normaliseSenderName, deriveMessageId;
-  try {
-    ({ parseExport, parseFilterArg, applyFilter } = await import(PARSE_EXPORT_PATH));
-    ({ memoryArchiveWrite } = await import(ARCHIVE_WRITE_PATH));
-    ({ getSession } = await import(NEO4J_LIB_PATH));
-    ({ normaliseSenderName, deriveMessageId } = await import(DERIVE_KEYS_PATH));
-  } catch (err) {
-    fail("import", {
-      reason: `failed to import compiled dist`,
-      detail: err instanceof Error ? err.message : String(err),
-    });
-  }
-
-  // 7a. Parse the operator-supplied filter ahead of any IO so a malformed
-  // value LOUD-FAILs before unzip / Neo4j connection.
-  let filter;
-  try {
-    filter = parseFilterArg(flags.filter);
-  } catch (err) {
-    fail("argv", { reason: err instanceof Error ? err.message : String(err) });
-  }
-
-  // 7b. Resolve _chat.txt
-  const { chatTxt, cleanup } = resolveChatTxt(archive);
-  const archiveBytes = statSync(chatTxt).size;
-  log(
-    `start file=${chatTxt} owner=${ownerElementId} scope=${scope} accountId=${accountId} archive-bytes=${archiveBytes} filter=${flags.filter}`,
-  );
-
-  // 7c. Parse
-  let parseResult;
-  const parseStart = Date.now();
-  try {
-    parseResult = parseExport({ filePath: chatTxt, accountId, timezone, dateFormat });
-  } catch (err) {
-    cleanup();
-    fail("parse", { reason: err instanceof Error ? err.message : String(err) });
-  }
-  const parseMs = Date.now() - parseStart;
-  log(
-    `parsed lines=${parseResult.counters.parsed} media-skipped=${parseResult.counters.mediaSkipped} system-skipped=${parseResult.counters.systemSkipped} ms=${parseMs}`,
-  );
-
-  // 7d. Apply filter
-  const filteredLines = applyFilter(parseResult.parsedLines, filter);
-  log(
-    `filter-applied kind=${filter.kind} parsed=${parseResult.parsedLines.length} filtered=${filteredLines.length}`,
-  );
-  if (filteredLines.length === 0) {
-    cleanup();
-    fail("filter", {
-      reason: `filter "${flags.filter}" matched zero rows from ${parseResult.parsedLines.length} parsed lines — refusing to write an empty conversation`,
-    });
-  }
-
-  const firstTs = filteredLines[0].dateSent;
-  const lastTs = filteredLines[filteredLines.length - 1].dateSent;
-
-  // 7e. Auto-create participants and build rows
-  let session = getSession();
-  let participantUpsert = { idsByName: new Map(), participantsAlreadyExisted: 0 };
-  const distinctSenderNames = Array.from(
-    new Set(filteredLines.map((l) => l.senderName)),
-  );
-
-  try {
-    participantUpsert = await bindCanonicalSenders({
-      session,
-      accountId,
-      ownerElementId,
-      subjectPersonId,
-      senderNames: distinctSenderNames,
-      normaliseSenderName,
-    });
-  } catch (err) {
-    await session.close().catch(() => {});
-    cleanup();
-    // IngestUserFacingError carries a brief-shaped FAIL line (parser-miss /
-    // unsupported-scope / argv mismatch) that the operator's grep recipes
-    // already match on. Preserve it verbatim instead of wrapping in
-    // phase=archive-write — wrapping would defeat
-    // `grep '\[whatsapp-ingest\] FAIL parser-miss'` and friends.
-    if (err && err.userFacing) {
-      process.stderr.write(`[whatsapp-ingest] FAIL ${err.message}\n`);
-      process.exit(1);
-    }
-    fail("archive-write", {
-      phase: "bind-canonical-senders",
-      reason: err instanceof Error ? err.message : String(err),
-    });
-  }
-
-  const participantIds = participantUpsert.idsByName;
-  const participantsAlreadyExisted = participantUpsert.participantsAlreadyExisted;
-
-  if (participantIds.size !== distinctSenderNames.length) {
-    log(
-      `participant-resolve mismatch expected=${distinctSenderNames.length} got=${participantIds.size}`,
-    );
-  }
-
-  const conversationId = parseResult.conversationId;
-  // Task 870: messageId derives from a content-derived natural key. Stable
-  // across re-imports — same archive bytes + same operator timezone produce
-  // identical messageIds, so the existing MERGE in memory-archive-write is
-  // naturally idempotent.
-  const conversationSha256 = parseResult.archiveSourceFile.replace(
-    /^whatsapp-export:/,
-    "",
-  );
-  const rows = filteredLines.map((l) => ({
-    messageId: deriveMessageId({
-      conversationSha256,
-      dateSent: l.dateSent,
-      senderName: l.senderName,
-      body: l.body,
-    }),
-    conversationId,
-    senderNodeId: participantIds.get(l.senderName) || ownerElementId,
-    senderName: l.senderName,
-    dateSent: l.dateSent,
-    body: l.body,
-    // sequenceIndex preserved on the Message node for chain ordering tiebreaker
-    // in WHATSAPP_NEXT_CHAIN_CYPHER. NOT part of messageId — that would couple
-    // identity to array position and re-introduce shadowing.
-    sequenceIndex: l.sequenceIndex,
-  }));
-
-  const conversationBlock = {
-    conversationId,
-    archiveSourceFile: parseResult.archiveSourceFile,
-    firstMessageAt: firstTs,
-    lastMessageAt: lastTs,
-    participantCount: distinctSenderNames.length,
-    messageCount: rows.length,
-  };
-
-  // Close the session before archive-write — memoryArchiveWrite opens its
-  // own session and closes it in finally.
-  await session.close().catch(() => {});
-
-  // 7f. Archive-write
-  let archiveResult;
-  const writeStart = Date.now();
-  try {
-    archiveResult = await memoryArchiveWrite({
-      archiveType: "whatsapp-export",
-      ownerNodeId: ownerElementId,
-      accountId,
-      conversation: conversationBlock,
-      participantNodeIds: Array.from(participantIds.values()),
-      rows,
-      sessionId,
-      archiveFilePath: chatTxt,
-    });
-  } catch (err) {
-    cleanup();
-    fail("archive-write", {
-      reason: err instanceof Error ? err.message : String(err),
-    });
-  }
-  const writeMs = Date.now() - writeStart;
-  const createdMessages = archiveResult.counters.createdMessages || 0;
-  const nextEdgesProcessed = archiveResult.counters.nextEdgesProcessed || 0;
-  const nextEdgesCreated = archiveResult.counters.nextEdgesCreated || 0;
-  const messagesAlreadyExisted = rows.length - createdMessages;
-  log(
-    `archive-write created-messages=${createdMessages} messages-already-existed=${messagesAlreadyExisted} next-edges-processed=${nextEdgesProcessed} next-edges-created=${nextEdgesCreated} participants-already-existed=${participantsAlreadyExisted} ms=${writeMs}`,
-  );
-
-  // 7g. Resolve conversationElementId for the agent-return shape (Task 871.6).
-  // One small read-after-write — the operator's database-operator subagent
-  // surfaces this as the canonical handle for downstream Phase 2 calls.
-  let conversationElementId = null;
-  const ridSession = getSession();
-  try {
-    const res = await ridSession.run(
-      `MATCH (c:Conversation:WhatsAppConversation {conversationId: $cid})
-       RETURN elementId(c) AS elemId LIMIT 1`,
-      { cid: conversationId },
-    );
-    conversationElementId = res.records[0]?.get("elemId") ?? null;
-  } catch (err) {
-    log(`conversation-elementid-lookup failed reason="${err instanceof Error ? err.message : String(err)}"`);
-  } finally {
-    await ridSession.close().catch(() => {});
-  }
-
-  cleanup();
-
-  const totalMs = Date.now() - startedMs;
-  log(`done conversationId=${conversationId} total-ms=${totalMs} exit=0`);
-
-  process.stdout.write(
-    JSON.stringify({
-      conversationElementId,
-      conversationId,
-      parsed: parseResult.counters.parsed,
-      mediaSkipped: parseResult.counters.mediaSkipped,
-      systemSkipped: parseResult.counters.systemSkipped,
-      filtered: filteredLines.length,
-      written: createdMessages,
-      messagesAlreadyExisted,
-      nextEdgesProcessed,
-      nextEdgesCreated,
-      participantsAlreadyExisted,
-      ms: totalMs,
-    }) + "\n",
-  );
-  process.exit(0);
-}
-
-
-main().catch((err) => {
-  fail("uncaught", { reason: err instanceof Error ? err.message : String(err) });
-});