@rubytech/create-maxy-code 0.1.158 → 0.1.161

package/payload/platform/plugins/memory/bin/conversation-archive-ingest.mjs

@@ -1,58 +1,58 @@
 #!/usr/bin/env node
 // =============================================================================
-// conversation-archive-ingest.mjs — in-process orchestrator for
-// conversation-archive-ingest.sh
-// env-only identity, fsync-per-line progress sink, per-session
-// checkpointing).
+// conversation-archive-ingest.mjs — thin parse-and-prepare helper for the
+// `conversation-archive` skill (Task 435).
 //
-// Source-agnostic. The same pipeline runs for every conversation source;
-// `--source <enum>` selects the normaliser at the top of the pipeline:
+// Contract (post-Task 435): this script does ONLY the deterministic work —
+// argv + env validation, source-file resolution, per-source normalisation,
+// archiveSha256 + conversationIdentity computation, owner + participant
+// verification, prior-archive cursor lookup, delta slicing, sessionization,
+// stable archive-title computation. It emits ONE JSON line on stdout
+// containing the prepared sessions array (turn-attributed text per session +
+// per-session cursor metadata) plus every identity/scope value the
+// `memory-ingest` MCP call needs. The script does NOT classify, does NOT
+// call `memory-ingest`, does NOT loop.
 //
-//   normalise  → bind canonical senders → derive conversationIdentity
-//   → look up prior :ConversationArchive (delta cursor)
-//   → sessionize delta at gap-hours boundaries
-//   → for each session: classify (mode='chat') → memoryIngest immediately
-//                       → advance lastIngestedMessageHash + lastIngestedMessageAt
+// The dispatched specialist drives the rest in-turn: for each session in the
+// emitted JSON, it reads the turn text, produces a typed-section JSON
+// chunking, and invokes `memory-ingest` with that session's sections + the
+// per-session cursor (`lastIngestedMessageHash`, `lastIngestedMessageAt`).
+// The first session's call carries `cleanupPriorChunks: true` iff the run
+// was invoked with `--rebuild`.
 //
-// Identity: `process.env.ACCOUNT_ID` and `process.env.USER_ID` are
-// the only inputs. Both are plumbed by `spawn-env.ts` into every Bash
-// subprocess; missing/malformed → LOUD-FAIL at phase=argv. `--account-id` and
-// `--owner-element-id` flags are GONE; the writer derives the AdminUser
-// elementId from (accountId, userId) one Cypher hop away.
+// Pre-Task-435 the script ran the Haiku classify + per-session memory-ingest
+// itself; that path was deleted in Task 424 (server-side classifier removed)
+// and finished off here in Task 435 (driver-side cleanup). The empty
+// classifier stub the .mjs carried between 424 and 435 produced one raw
+// unenriched `:Conversation` chunk per session — that path is gone too.
 //
 // Argv (positional): <archive-path>
 // Argv (flags):       --source <enum>
 //                     --participant-person-ids <csv>
 //                     --scope <admin|public>
-//                     [--rebuild]                  (destructive rebuild)
+//                     [--rebuild]
 //                     [--timezone <iana>]
 //                     [--date-format <DD/MM/YY|MM/DD/YY|DD/MM/YYYY|MM/DD/YYYY>]
-//                     [--session-id <id>]
 //
-// Sessions split at SESSION_GAP_HOURS=8 (fixed constant). The flag
-// `--session-gap-hours` is REMOVED; passing it FAILs at phase=argv. The
-// chunked chat-mode classify path (sub-scope C) absorbs oversize
-// sessions internally — no operator lever required.
+// Identity: `process.env.ACCOUNT_ID` and `process.env.USER_ID` are the only
+// inputs. Both are plumbed by `spawn-env.ts` into every Bash subprocess;
+// missing/malformed → LOUD-FAIL at phase=argv. The writer derives the owner
+// :AdminUser elementId from (accountId, userId) one Cypher hop away.
 //
-// Stdout (success): one JSON line — counters the skill needs to formulate
-// the three operator-facing messages. See SKILL.md for the shape.
-// Stderr + progress file: `[conversation-archive] ...` lines, fsync per write.
-// Progress path: data/accounts/<accountId>/logs/conversation-archive-<sessionId>.log
-// Wrapper sh prints `[conversation-archive] progress-file=<absolute-path>` on
-// stdout before exec node, so the agent computes nothing.
+// Sessions split at SESSION_GAP_HOURS=8 (fixed constant). The legacy
+// `--session-gap-hours` flag is REMOVED; passing it FAILs at phase=argv.
+//
+// Stdout (success): one JSON line. See SKILL.md for the shape.
+// Stderr: `[conversation-archive] FAIL phase=<…> reason="..."` on failure.
+// Exit 0 on success; non-zero on failure.
 // =============================================================================
 
 import {
-  closeSync,
   existsSync,
-  fsyncSync,
-  mkdirSync,
   mkdtempSync,
-  openSync,
   readdirSync,
   rmSync,
   statSync,
-  writeSync,
 } from "node:fs";
 import { join, resolve, dirname } from "node:path";
 import { tmpdir } from "node:os";
@@ -61,116 +61,34 @@ import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-// sub-scope D — fixed session gap. Pre-902 this was a CLI flag with a
-// 12h default; oversize sessions on dense archives drove operators to re-issue
-// with a smaller gap, which combined with cleanup-by-archiveSha256 to silently
-// destroy 138 chunks (Adam Mackay incident, 2026-05-04). The flag is gone;
-// chunked chat-mode classify (sub-scope C) absorbs oversize sessions
-// internally so the gap value is no longer an operational lever. 8h is a
-// tighter default than 12h and matches the operator-decided post-incident
-// constant.
+// Fixed session gap — pre-902 this was a CLI flag with a 12h default; oversize
+// sessions on dense archives drove operators to re-issue with a smaller gap,
+// which combined with cleanup-by-archiveSha256 to silently destroy 138 chunks
+// (Adam Mackay incident, 2026-05-04). The flag is gone; the in-turn classify
+// path absorbs oversize sessions on the specialist side now.
 const SESSION_GAP_HOURS = 8;
 
-// ---------------------------------------------------------------------------
-// 1. Resolve dist paths.
-// ---------------------------------------------------------------------------
 const platformRoot =
   process.env.MAXY_PLATFORM_ROOT?.trim() ||
   resolve(__dirname, "..", "..", "..");
 
 const NORMALISERS_PATH = resolve(
-  platformRoot,
-  "plugins",
-  "memory",
-  "mcp",
-  "dist",
-  "lib",
-  "conversation-normalisers",
-  "index.js",
+  platformRoot, "plugins", "memory", "mcp", "dist", "lib",
+  "conversation-normalisers", "index.js",
 );
 const PIPELINE_PATH = resolve(
-  platformRoot,
-  "plugins",
-  "memory",
-  "mcp",
-  "dist",
-  "lib",
+  platformRoot, "plugins", "memory", "mcp", "dist", "lib",
   "conversation-pipeline",
 );
 const NEO4J_LIB_PATH = resolve(
-  platformRoot,
-  "plugins",
-  "memory",
-  "mcp",
-  "dist",
-  "lib",
-  "neo4j.js",
-);
-// LLM_CLASSIFIER_PATH removed by Task 424. Task 435 reintroduces per-chunk
-// enrichment as in-turn specialist work.
-const MEMORY_INGEST_PATH = resolve(
-  platformRoot,
-  "plugins",
-  "memory",
-  "mcp",
-  "dist",
-  "tools",
-  "memory-ingest.js",
+  platformRoot, "plugins", "memory", "mcp", "dist", "lib", "neo4j.js",
 );
 const UUID_LIB_PATH = resolve(
-  platformRoot,
-  "plugins",
-  "memory",
-  "mcp",
-  "dist",
-  "lib",
-  "uuid.js",
+  platformRoot, "plugins", "memory", "mcp", "dist", "lib", "uuid.js",
 );
 
-// ---------------------------------------------------------------------------
-// 2. Progress sink + logger fan-out (sub-scope A).
-//    `log()` and `fail()` write to stderr AND the progress file with fsync per
-//    write. Parent Bash returns nothing until child exits; the progress file
-//    is the only surface the agent's heartbeat poll can read mid-run.
-// ---------------------------------------------------------------------------
-let progressFd = -1;
 const startedMs = Date.now();
 
-function openProgressSink(absolutePath) {
-  mkdirSync(dirname(absolutePath), { recursive: true });
-  progressFd = openSync(absolutePath, "a");
-}
-
-function writeProgressLine(line) {
-  // stderr first — preserves existing observability for parents that read
-  // stderr after the child exits, AND makes the line visible via the
-  // mcp-spawn-tee'd device server.log without a separate sink.
-  process.stderr.write(line);
-  if (progressFd >= 0) {
-    try {
-      writeSync(progressFd, line);
-      fsyncSync(progressFd);
-    } catch {
-      // Disk pressure / EBADF: don't kill the run — stderr already carries
-      // the line.
-    }
-  }
-}
-
-function log(line) {
-  writeProgressLine(`[conversation-archive] ${line}\n`);
-}
-
-function endRun(exitCode) {
-  const totalMs = Date.now() - startedMs;
-  writeProgressLine(`[conversation-archive] end exit-code=${exitCode} ms=${totalMs}\n`);
-  if (progressFd >= 0) {
-    try { closeSync(progressFd); } catch { /* fd already closed */ }
-    progressFd = -1;
-  }
-  process.exit(exitCode);
-}
-
 function fail(phase, fields) {
   const fieldStr = Object.entries(fields)
     .map(([k, v]) =>
@@ -179,12 +97,12 @@ function fail(phase, fields) {
         : `${k}=${v ?? "-"}`,
     )
     .join(" ");
-  writeProgressLine(`[conversation-archive] FAIL phase=${phase} ${fieldStr}\n`);
-  endRun(1);
+  process.stderr.write(`[conversation-archive] FAIL phase=${phase} ${fieldStr}\n`);
+  process.exit(1);
 }
 
 // ---------------------------------------------------------------------------
-// 3. Argv parsing
+// Argv parsing
 // ---------------------------------------------------------------------------
 const VALID_SOURCES = new Set([
   "whatsapp",
@@ -195,12 +113,17 @@ const VALID_SOURCES = new Set([
   "meeting-minutes",
   "imessage",
   "slack",
+  "x-dm",
+  "email",
   "other",
 ]);
 
-// Boolean flags carry no value; every other flag consumes the following arg.
 const BOOLEAN_FLAGS = new Set(["rebuild"]);
 
+function camelCase(s) {
+  return s.replace(/-([a-z])/g, (_m, c) => c.toUpperCase());
+}
+
 function parseArgv(argv) {
   const args = argv.slice(2);
   let archive = null;
@@ -213,9 +136,6 @@ function parseArgv(argv) {
       continue;
     }
     const key = a.slice(2);
-    // sub-scope D — the flag re-introduced the surface that enabled
-    // the silent-partial-wipe failure (Defect B). Reject loudly with the
-    // remediation the operator should use instead.
     if (key === "session-gap-hours") {
       fail("argv", {
         reason: `--session-gap-hours is no longer supported; gap is fixed at 8h. Use --rebuild on the prior export bytes if you need to re-classify.`,
@@ -232,7 +152,7 @@ function parseArgv(argv) {
   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)` });
+    fail("argv", { reason: `invalid --source "${flags.source}" (whatsapp|telegram|signal|linkedin-messages|zoom-transcript|meeting-minutes|imessage|slack|x-dm|email|other)` });
   }
   if (!flags.participantPersonIds) {
     fail("argv", {
@@ -245,13 +165,10 @@ function parseArgv(argv) {
   }
   return { archive, flags };
 }
-function camelCase(s) {
-  return s.replace(/-([a-z])/g, (_m, c) => c.toUpperCase());
-}
 
 // ---------------------------------------------------------------------------
-// 4. Archive resolution. WhatsApp ships zip-or-dir-or-_chat.txt; other
-//    sources pass a single file path that the normaliser interprets directly.
+// Archive resolution. WhatsApp ships zip-or-dir-or-_chat.txt; other sources
+// pass a single file path the normaliser interprets directly.
 // ---------------------------------------------------------------------------
 function resolveSourceFile(archivePath, source) {
   const abs = resolve(archivePath);
@@ -290,6 +207,7 @@ function resolveSourceFile(archivePath, source) {
   fail("argv", { reason: `unsupported archive shape for source=${source}: ${abs}` });
   return { sourceFile: abs, cleanup: () => {} };
 }
+
 function findChatTxt(dir) {
   const entries = readdirSync(dir, { withFileTypes: true });
   for (const e of entries) {
@@ -305,28 +223,17 @@ function findChatTxt(dir) {
 }
 
 // ---------------------------------------------------------------------------
-// 4b. Stable archive title (sub-scope A).
-//
-// Format: `<source> · <owner> ↔ <other1>, <other2>, … · <YYYY-MM-DD>→<YYYY-MM-DD>`.
-//
-// The title is computed once per ingest from inputs that are immutable for
+// Stable archive title — computed once per ingest from inputs immutable for
 // the conversation (source, accountId, sortedParticipantElementIds, archive
 // dateRange) so re-ingests produce the same string. Memory-ingest writes it
-// to the `:ConversationArchive.title` ON CREATE and COALESCE-on-MATCH so the UI
-// (display-helpers.ts) reads a stable label without ever falling through to
-// `summary`. Per-session counter strings stay in the progress file only.
-//
+// ON CREATE and COALESCE-on-MATCH; the UI reads `:ConversationArchive.title`
+// directly. Format:
+//   `<source> · <owner> ↔ <other1>, <other2>, … · <YYYY-MM-DD>→<YYYY-MM-DD>`
 // Names: AdminUser uses `displayName` then `slug`; Person composes
-// `givenName + familyName`. When neither resolves, fall back to a short
-// elementId prefix — same degraded format the migration uses on backfill,
-// so a re-ingest after the migration produces the same title shape that
-// already populated the node.
+// `givenName + familyName`. Missing names fall back to short elementId
+// prefixes — same degraded format the migration uses.
 // ---------------------------------------------------------------------------
-
 function isoToYmd(iso) {
-  // Read the YYYY-MM-DD prefix verbatim — same tz-stable contract as
-  // formatRunDate in display-helpers.ts. Parsing to Date + reformatting
-  // would flip the day between operator timezones.
   const m = typeof iso === "string" ? iso.match(/^(\d{4}-\d{2}-\d{2})/) : null;
   return m ? m[1] : "?";
 }
@@ -348,16 +255,11 @@ function pickNameForRow(labels, props) {
 }
 
 async function computeArchiveTitle({
-  source,
-  accountId,
-  ownerElementId,
-  participantElementIds,
-  firstMessageAt,
-  lastMessageAt,
-  getSession,
+  source, accountId, ownerElementId, participantElementIds,
+  firstMessageAt, lastMessageAt, getSession,
 }) {
   const session = getSession();
-  let nameByElementId = new Map();
+  const nameByElementId = new Map();
   try {
     const ids = [ownerElementId, ...participantElementIds];
     const r = await session.run(
@@ -380,22 +282,16 @@ async function computeArchiveTitle({
   const otherNames = participantElementIds
     .map((id) => nameByElementId.get(id) || id.slice(0, 8))
     .join(", ");
-  const firstYmd = isoToYmd(firstMessageAt);
-  const lastYmd = isoToYmd(lastMessageAt);
-  return `${source} · ${ownerName} ↔ ${otherNames} · ${firstYmd}→${lastYmd}`;
+  return `${source} · ${ownerName} ↔ ${otherNames} · ${isoToYmd(firstMessageAt)}→${isoToYmd(lastMessageAt)}`;
 }
 
 // ---------------------------------------------------------------------------
-// 5. Main
+// Main
 // ---------------------------------------------------------------------------
 async function main() {
   const { archive, flags } = parseArgv(process.argv);
   const source = flags.source;
 
-  // Identity is env-only (sub-scope C). spawn-env.ts plumbs both
-  // ACCOUNT_ID and USER_ID into every Bash subprocess; the bin LOUD-FAILs if
-  // either is absent or malformed. The disk-scan resolver and the
-  // --account-id / --owner-element-id flags are gone.
   let UUID_REGEX;
   try {
     ({ UUID_REGEX } = await import(UUID_LIB_PATH));
@@ -431,36 +327,14 @@ async function main() {
   const scope = flags.scope;
   const timezone = flags.timezone || "Europe/London";
   const dateFormat = flags.dateFormat;
-  // sub-scope B — `--rebuild` is the single opt-in for destructive
-  // re-run-with-same-bytes. Without it, re-issuing the bin on the same export
-  // is a no-op (chunk-count summary, exit 0). With it, the bin treats the run
-  // as first-ingest (skips prior-cursor lookup) and the FIRST session's
-  // memoryIngest call cleans prior chunks for the archiveSha256.
   const rebuild = flags.rebuild === true;
-  const sessionId =
-    flags.sessionId ||
-    `conversation-archive:${source}:${Date.now()}:${Math.random().toString(36).slice(2, 10)}`;
-
-  // ---------------------------------------------------------------------------
-  // Open progress sink BEFORE any await. Path is deterministic from
-  // (accountId, sessionId); the wrapper sh prints the same path on stdout so
-  // the agent's heartbeat polls the right file.
-  // ---------------------------------------------------------------------------
-  const accountsDir = resolve(platformRoot, "..", "data", "accounts");
-  const logsDir = resolve(accountsDir, accountId, "logs");
-  const progressFilePath = resolve(logsDir, `conversation-archive-${sessionId}.log`);
-  openProgressSink(progressFilePath);
-
-  log(
-    `start session=${sessionId} source=${source} archive=${archive} accountId=${accountId} userId=${userId} participants=${participantElementIds.length} scope=${scope} pid=${process.pid}`,
-  );
 
   // Imports — fail loudly if any compiled dist missing
   let getNormaliser;
   let sessionize, toTurnText, findDeltaCursor;
   let deriveConversationIdentity, deriveMessageContentHash;
   let verifyParticipantElementIds;
-  let getSession, memoryIngest;
+  let getSession;
   try {
     ({ getNormaliser } = await import(NORMALISERS_PATH));
     ({ sessionize } = await import(join(PIPELINE_PATH, "sessionize.js")));
@@ -470,7 +344,6 @@ async function main() {
       await import(join(PIPELINE_PATH, "derive-keys.js")));
     ({ verifyParticipantElementIds } = await import(join(PIPELINE_PATH, "sender-bind.js")));
     ({ getSession } = await import(NEO4J_LIB_PATH));
-    ({ memoryIngest } = await import(MEMORY_INGEST_PATH));
   } catch (err) {
     fail("import", {
       reason: "failed to import compiled dist",
@@ -478,20 +351,7 @@ async function main() {
     });
   }
 
-  // Task 424 — per-session Haiku enrichment removed. Every session lands as an
-  // unenriched raw `:Conversation` chunk; topic summaries / keywords / per-chunk
-  // boundaries are reintroduced under Task 435 (specialist produces them
-  // in-turn). Until then, the driver still ingests the archive — operator gets
-  // the conversation in the graph, just without per-chunk enrichment.
-  const classifyDocument = async ({ documentText }) => ({
-    kind: "error",
-    reason: "Task 424 — server-side classifier removed; Task 435 introduces in-turn enrichment.",
-    documentText,
-  });
-
-  // Resolve owner AdminUser elementId from (accountId, userId). One Cypher
-  // hop replaces the deleted --owner-element-id flag — owner identity is env
-  // input, never an out-of-band flag.
+  // Resolve owner :AdminUser elementId from (accountId, userId).
   let ownerElementId;
   {
     const lookupSession = getSession();
@@ -517,12 +377,11 @@ async function main() {
     }
     await lookupSession.close().catch(() => {});
   }
-  log(`owner-resolved ownerElementId=${ownerElementId.slice(0, 12)} userId=${userId.slice(0, 8)}`);
 
-  // 6a. Resolve source file
+  // Resolve source file
   const { sourceFile, cleanup } = resolveSourceFile(archive, source);
 
-  // 6b. Run the source-specific normaliser
+  // Run the source-specific normaliser
   let normaliserResult;
   try {
     const normaliser = getNormaliser(source);
@@ -539,16 +398,10 @@ async function main() {
   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)} gap=${SESSION_GAP_HOURS} rebuild=${rebuild}`,
-  );
-  log(
-    `parsed lines=${normaliserResult.counters.parsed} media-skipped=${normaliserResult.counters.mediaSkipped} system-skipped=${normaliserResult.counters.systemSkipped}`,
-  );
-  // zero matched timestamps means this isn't a chat archive — the
-  // file should route through document-ingest instead. The agent's
-  // database-operator skill picks the right entry; this LOUD-FAIL surfaces
-  // misroute as an actionable signal rather than a silent empty ingest.
+
+  // Zero matched timestamps means this isn't a chat archive — route through
+  // document-ingest instead. LOUD-FAIL surfaces misroute as an actionable
+  // signal rather than a silent empty ingest.
   if (allLines.length === 0) {
     cleanup();
     fail("parse", {
@@ -556,50 +409,46 @@ async function main() {
     });
   }
 
-  // 6c. Verify participant elementIds resolve to graph nodes with the right
-  // accountId and labels. Per-line senderName binding is gone;
-  // operator-confirmed participants attach to the :ConversationArchive parent.
+  // Verify operator-confirmed participants resolve to graph nodes with the
+  // right accountId and labels. Per-line senderName binding is gone; only
+  // owner + operator-confirmed participants attach via :PARTICIPANT_IN.
   let session = getSession();
   try {
     await verifyParticipantElementIds({
-      session,
-      accountId,
-      ownerElementId,
-      participantElementIds,
+      session, accountId, ownerElementId, participantElementIds,
     });
   } catch (err) {
     await session.close().catch(() => {});
     cleanup();
     if (err && err.userFacing) {
-      writeProgressLine(`[conversation-archive] FAIL ${err.message}\n`);
-      endRun(1);
+      process.stderr.write(`[conversation-archive] FAIL ${err.message}\n`);
+      process.exit(1);
     }
     fail("argv", { reason: err instanceof Error ? err.message : String(err) });
   }
 
-  // 6d. Derive conversationIdentity and look up the prior :ConversationArchive parent (Task 397).
-  // sub-scope B — under `--rebuild` we skip the prior-cursor lookup
-  // entirely; the run is treated as first-ingest, the first session cleans
-  // prior chunks (cleanupPriorChunks=true), and the cursor is overwritten
-  // by that session's MERGE. Without `--rebuild`, the prior cursor drives
-  // delta-append OR (sub-scope B) the same-bytes no-op exit when
-  // chunks already exist for this archiveSha256.
+  // Derive conversationIdentity and look up prior :ConversationArchive (Task
+  // 397). Under `--rebuild` we skip the prior-cursor lookup entirely; the
+  // run is treated as first-ingest, and the specialist's first memory-ingest
+  // call will carry `cleanupPriorChunks: true` to drop prior chunks for this
+  // archiveSha256.
   const conversationIdentity = deriveConversationIdentity({
     accountId,
     participantElementIds: [ownerElementId, ...participantElementIds],
+    source,
   });
   let priorArchive = null;
   let priorChunkCountForSha = 0;
   if (!rebuild) {
     try {
       const r = await session.run(
-        `MATCH (a:ConversationArchive { conversationIdentity: $cid })
+        `MATCH (a:ConversationArchive { conversationIdentity: $cid, source: $source })
          OPTIONAL MATCH (a)-[:HAS_SECTION]->(c:Section { archiveSha256: $sha })
          RETURN elementId(a) AS elemId,
                 a.lastIngestedMessageHash AS lastHash,
                 a.lastIngestedMessageAt   AS lastAt,
                 count(c)                  AS chunksForSha LIMIT 1`,
-        { cid: conversationIdentity, sha: archiveSha256 },
+        { cid: conversationIdentity, source, sha: archiveSha256 },
       );
       if (r.records[0] && r.records[0].get("elemId")) {
         priorArchive = {
@@ -619,11 +468,12 @@ async function main() {
   }
   await session.close().catch(() => {});
 
-  // 6e. Compute deltaStart. Three branches:
-  //   (i) --rebuild: deltaStart=0, kind=rebuild, classify entire archive.
+  // Compute deltaStart. Three branches:
+  //   (i) --rebuild: deltaStart=0, kind=rebuild, prepare entire archive.
   //  (ii) no prior archive (or no cursor): first-ingest, deltaStart=0.
   // (iii) prior archive + cursor: standard delta-append. Same-bytes (no
-  //       cursor advance possible) AND chunks exist for this sha → no-op.
+  //       cursor advance possible) AND chunks exist for this sha → emit
+  //       empty-delta JSON; specialist surfaces a noop message.
   let deltaStart = 0;
   let deltaKind = rebuild ? "rebuild" : "first-ingest";
   if (!rebuild && priorArchive && priorArchive.lastHash) {
@@ -637,243 +487,93 @@ async function main() {
       });
     }
     if (cursor.kind === "empty") {
-      log(`noop reason="no new messages since ${priorArchive.lastAt}" prior-chunks=${priorChunkCountForSha}`);
       cleanup();
-      const totalMs = Date.now() - startedMs;
       process.stdout.write(JSON.stringify({
         archiveElementId: priorArchive.elemId,
         conversationIdentity,
         archiveSha256,
         archiveSourceFile,
         source,
+        scope,
+        accountId,
+        ownerElementId,
+        participantElementIds,
+        rebuild,
         parsed: normaliserResult.counters.parsed,
         mediaSkipped: normaliserResult.counters.mediaSkipped,
         systemSkipped: normaliserResult.counters.systemSkipped,
         delta: { kind: "empty-delta", deltaStart: allLines.length, deltaMessages: 0 },
-        sessions: 0,
-        chunks: priorChunkCountForSha,
-        nextEdgesCreated: 0,
-        participantsLinked: 0,
         dateRange: { first: allLines[0].dateSent, last: allLines[allLines.length - 1].dateSent },
-        parsedLineCount: allLines.length,
-        sessionsUnenriched: 0,
-        topicKeywords: [],
-        ms: totalMs,
+        senderHistogram: normaliserResult.counters.senderHistogram ?? [],
+        priorChunkCount: priorChunkCountForSha,
         priorLastIngestedMessageAt: priorArchive.lastAt,
+        sessions: [],
+        ms: Date.now() - startedMs,
       }) + "\n");
-      endRun(0);
+      process.exit(0);
     }
     deltaStart = cursor.deltaStart;
     deltaKind = "delta";
   }
   const deltaLines = allLines.slice(deltaStart);
-  log(
-    `delta kind=${deltaKind} cursor=${priorArchive && priorArchive.lastHash && !rebuild ? priorArchive.lastHash.slice(0, 12) : "(first-ingest)"} cursor-line=${deltaStart} delta-messages=${deltaLines.length}`,
-  );
 
-  // 6f. Sessionize delta at the fixed 8h gap (sub-scope D).
+  // Sessionize delta at the fixed 8h gap.
   const sessions = sessionize(deltaLines, SESSION_GAP_HOURS);
-  log(
-    `sessionize source=${source} archiveSha256=${archiveSha256.slice(0, 12)} messages=${deltaLines.length} sessions=${sessions.length} gap-hours=${SESSION_GAP_HOURS}`,
-  );
-
-  // sub-scope A — compute the stable archive title once, before
-  // the per-session loop. The title is `<source> · <owner> ↔ <others> ·
-  // <YYYY-MM-DD>→<YYYY-MM-DD>`. Operator-confirmed participant names come
-  // from one Cypher hop; absent canonical names fall back to elementId
-  // prefixes so the migration's degraded-title path mirrors live behaviour.
+
+  // Stable archive title — computed once from the full archive's date range
+  // (not the delta), so a delta-append re-ingest produces the same title.
   const archiveTitle = await computeArchiveTitle({
-    source,
-    accountId,
-    ownerElementId,
-    participantElementIds,
+    source, accountId, ownerElementId, participantElementIds,
     firstMessageAt: allLines[0].dateSent,
     lastMessageAt: allLines[allLines.length - 1].dateSent,
     getSession,
   });
-  log(`archive-title=${archiveTitle}`);
-
-  // 6g. Per-session classify + immediate memoryIngest (sub-scope E).
-  // Each session commits atomically: chunks + cursor advance happen together
-  // via memoryIngest. A kill mid-loop leaves a partial archive whose cursor
-  // is at session N-1's last message; the next invocation slices from there
-  // and re-classifies only session N onward. degrade-on-error
-  // is preserved: a Haiku error on session N still emits an unenriched chunk
-  // and advances the cursor, so resumption never re-attempts the same Haiku
-  // error.
-  const allKeywords = new Set();
-  let sessionsUnenriched = 0;
-  let totalChunksWritten = 0;
-  let totalNextEdges = 0;
-  let participantsLinked = 0;
-  let archiveElementIdLatest = priorArchive ? priorArchive.elemId : "";
-
-  for (let sIdx = 0; sIdx < sessions.length; sIdx++) {
-    const s = sessions[sIdx];
-    const isFirstSessionInRun = sIdx === 0;
-    const sessionStart = Date.now();
-    const text = toTurnText(s);
-    const result = await classifyDocument({
-      accountId,
-      mode: "chat",
-      anchorDescription: `Conversation transcript (${[ownerElementId, ...participantElementIds].length} participants, session ${s.index + 1} of ${sessions.length})`,
-      ontologyLabels: new Set([]),
-      naturalEdgeMap: "",
-      documentText: text,
-    });
 
-    let sessionChunks;
-    let sessionKeywords = [];
-    if (result.kind === "error") {
-      sessionsUnenriched += 1;
-      log(`session-unenriched session=${s.index + 1}/${sessions.length} reason="${result.reason.replace(/"/g, '\\"')}"`);
-      // Emit one raw conversation :Section chunk covering the whole session.
-      // No summary, no topicKeywords — a follow-up pass can re-enrich.
-      sessionChunks = [{
-        kind: "Conversation",
-        title: `Unenriched session ${s.index + 1}`,
-        body: text,
-        summary: "",
-        sourceStart: 0,
-        sourceEnd: text.length,
-        properties: {
-          unenriched: true,
-          unenrichedReason: result.reason,
-          firstMessageAt: s.firstMessageAt,
-          lastMessageAt: s.lastMessageAt,
-          messageCount: s.messages.length,
-        },
-        anchorEdge: null,
-      }];
-    } else {
-      const chunkCount = result.output.sections.length;
-      log(
-        `classify-session sessionIndex=${s.index + 1}/${sessions.length} messages=${s.messages.length} chars=${text.length} chunks=${chunkCount} ms=${Date.now() - sessionStart}`,
-      );
-      if (chunkCount === 0 && s.messages.length > 0) {
-        cleanup();
-        fail("classify", {
-          reason: `session ${s.index} of ${s.messages.length} messages produced zero chunks (classifier-prompt regression)`,
-        });
-      }
-      sessionChunks = result.output.sections;
-      sessionKeywords = result.output.documentKeywords ?? [];
-      for (const kw of sessionKeywords) allKeywords.add(kw);
-    }
-
-    // Per-session cursor: advance to THIS session's last message. Atomic with
-    // chunk writes inside memoryIngest's MERGE/CREATE Cypher transaction.
-    const lastSessionLine = s.messages[s.messages.length - 1];
-    const sessionLastHash = deriveMessageContentHash({
-      dateSent: lastSessionLine.dateSent,
-      body: lastSessionLine.body,
-    });
-    const sessionLastAt = lastSessionLine.dateSent;
-
-    let ingestResult;
-    const ingestStart = Date.now();
-    try {
-      ingestResult = await memoryIngest({
-        accountId,
-        conversationIdentity,
-        source,
-        // sub-scope A — `archiveTitle` is the stable label written
-        // to the conversation-document parent's `title` property (UI
-        // prefers it over `summary`). `documentSummary` is also the stable
-        // title rather than the per-session counter that previously locked
-        // the parent's first checkpoint into "Session 1/N: …".
-        archiveTitle,
-        documentSummary: archiveTitle,
-        anchorNodeId: ownerElementId,
-        anchorLabel: "AdminUser",
-        sections: sessionChunks,
-        scope,
-        sessionId,
-        documentKeywords: Array.from(allKeywords),
-        archiveSha256,
-        archiveSourceFile,
-        lastIngestedMessageHash: sessionLastHash,
-        lastIngestedMessageAt: sessionLastAt,
-        participantElementIds: [ownerElementId, ...participantElementIds],
-        // sub-scope B — cleanup-by-archiveSha256 runs ONLY under
-        // `--rebuild`, AND only on the first session of the run (subsequent
-        // sessions skip cleanup or they would delete chunks the earlier
-        // sessions in the same run just wrote).
-        cleanupPriorChunks: rebuild && isFirstSessionInRun,
-      });
-    } catch (err) {
-      cleanup();
-      fail("memory-ingest", {
-        reason: err instanceof Error ? err.message : String(err),
-        sessionIndex: s.index + 1,
-        sessionsTotal: sessions.length,
-      });
-    }
-
-    archiveElementIdLatest = ingestResult.documentNodeId;
-    totalChunksWritten += ingestResult.sectionCount;
-    totalNextEdges += ingestResult.edgeBreakdown.NEXT ?? 0;
-    if (isFirstSessionInRun) {
-      participantsLinked = ingestResult.edgeBreakdown.PARTICIPANT_IN ?? 0;
-      // sub-scope E — surface destructive cleanup as a WARN line in
-      // the progress sink (not just memory-ingest's stderr). The agent's
-      // heartbeat grep-matches this exact prefix and elevates to operator
-      // chat. Cleanup only ever fires under `--rebuild` per sub-scope B,
-      // so seeing the line outside of an operator-issued `--rebuild` is a
-      // doctrine violation worth surfacing loudly.
-      const cleaned = ingestResult.cleanedPriorChunks ?? 0;
-      if (cleaned > 0) {
-        log(
-          `WARN cleanup-dropped chunks=${cleaned} archiveSha256=${archiveSha256.slice(0, 12)} — prior data deleted, expected only under --rebuild`,
-        );
-      }
-    }
-    log(
-      `session-committed sessionIndex=${s.index + 1}/${sessions.length} chunks-written=${ingestResult.sectionCount} cursor-at="${sessionLastAt}" ms=${Date.now() - ingestStart}`,
-    );
-    // sub-scope F — derived progress line. The agent's heartbeat
-    // surfaces only `progress` lines as chat tokens; raw `classify-session`
-    // and `session-committed` lines remain on disk for diagnosis. The render
-    // is computed in the bin (deterministic) instead of in SKILL.md prose
-    // (LLM drift) — sessionIndex/N → P% with running totals comes from one
-    // place, not from per-tick agent arithmetic.
-    const pct = Math.round((100 * (s.index + 1)) / sessions.length);
-    log(
-      `progress sessionIndex=${s.index + 1}/${sessions.length} pct=${pct} chunks-so-far=${totalChunksWritten} elapsed-ms=${Date.now() - startedMs}`,
-    );
-  }
-
-  if (sessionsUnenriched > 0) {
-    log(`classify-summary sessions=${sessions.length} unenriched=${sessionsUnenriched} enriched=${sessions.length - sessionsUnenriched}`);
-  }
+  // Build the per-session payload the specialist iterates in-turn. Each entry
+  // carries the turn text the specialist classifies + the cursor values the
+  // specialist passes through to `memory-ingest` for atomic checkpointing.
+  const sessionPayloads = sessions.map((s, sIdx) => {
+    const lastMessage = s.messages[s.messages.length - 1];
+    return {
+      sessionIndex: sIdx + 1,
+      totalSessions: sessions.length,
+      messageCount: s.messages.length,
+      firstMessageAt: s.firstMessageAt,
+      lastMessageAt: s.lastMessageAt,
+      lastMessageHash: deriveMessageContentHash({
+        dateSent: lastMessage.dateSent,
+        body: lastMessage.body,
+      }),
+      turnText: toTurnText(s),
+    };
+  });
 
   cleanup();
-  const totalMs = Date.now() - startedMs;
-  log(
-    `done source=${source} conversationIdentity=${conversationIdentity.slice(0, 12)} archiveElementId=${archiveElementIdLatest} chunks-written=${totalChunksWritten} sessions=${sessions.length} total-ms=${totalMs}`,
-  );
 
   process.stdout.write(JSON.stringify({
-    archiveElementId: archiveElementIdLatest,
+    archiveElementId: priorArchive ? priorArchive.elemId : null,
     conversationIdentity,
     archiveSha256,
     archiveSourceFile,
+    archiveTitle,
     source,
+    scope,
+    accountId,
+    ownerElementId,
+    participantElementIds,
+    rebuild,
     parsed: normaliserResult.counters.parsed,
     mediaSkipped: normaliserResult.counters.mediaSkipped,
     systemSkipped: normaliserResult.counters.systemSkipped,
     delta: { kind: deltaKind, deltaStart, deltaMessages: deltaLines.length },
-    sessions: sessions.length,
-    chunks: totalChunksWritten,
-    nextEdgesCreated: totalNextEdges,
-    participantsLinked,
     dateRange: { first: allLines[0].dateSent, last: allLines[allLines.length - 1].dateSent },
-    parsedLineCount: allLines.length,
-    sessionsUnenriched,
-    topicKeywords: Array.from(allKeywords),
-    ms: totalMs,
+    senderHistogram: normaliserResult.counters.senderHistogram ?? [],
+    priorChunkCount: priorChunkCountForSha,
+    priorLastIngestedMessageAt: priorArchive ? priorArchive.lastAt : null,
+    sessions: sessionPayloads,
+    ms: Date.now() - startedMs,
   }) + "\n");
-  endRun(0);
+  process.exit(0);
 }
 
 main().catch((err) => {