@rubytech/create-maxy 1.0.875 → 1.0.877

package/payload/platform/plugins/memory/mcp/dist/tools/conversation-archive-enrich-rejection.d.ts

@@ -0,0 +1,41 @@
+/**
+ * conversation-archive-enrich-rejection MCP tool — Task 980.
+ *
+ * Durable rejection memory for conversation-archive-enrich. Writes to a
+ * sidecar JSONL file alongside the account's state directory; the read side
+ * (filter step) lives in `conversation-archive-derive-insights.ts` so the
+ * path constant has a single source of truth.
+ *
+ * Modes:
+ *   record — append a rejection line. O_APPEND is POSIX-atomic for writes
+ *            ≤ PIPE_BUF; one JSONL line is well under that, so concurrent
+ *            appends never corrupt the file.
+ *   undo   — read all lines, drop matches by (chunkElementId, kind,
+ *            contentHash), then atomic-rename the rewritten file. A `wire`
+ *            of the same key triggers undo so the operator's change of mind
+ *            doesn't leave stale rejections behind.
+ *
+ * Residual race: a `record` append landing between the `undo`'s read and
+ * rename is overwritten. The per-row operator gate is single-threaded
+ * (one chat-turn at a time), so this window is not exploitable in normal
+ * operation. A `flock`-based fix is deferred until rejection volume warrants.
+ */
+export type RejectionMode = "record" | "undo";
+export interface RecordRejectionParams {
+    accountId: string;
+    archiveElementId: string;
+    chunkElementId: string;
+    kind: string;
+    contentHash: string;
+    mode: RejectionMode;
+    sessionId?: string;
+}
+export interface RecordRejectionResult {
+    ok: true;
+    mode: RejectionMode;
+    beforeCount: number;
+    afterCount: number;
+    path: string;
+}
+export declare function conversationArchiveEnrichRejection(params: RecordRejectionParams): RecordRejectionResult;
+//# sourceMappingURL=conversation-archive-enrich-rejection.d.ts.map

package/payload/platform/plugins/memory/mcp/dist/tools/conversation-archive-enrich-rejection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-archive-enrich-rejection.d.ts","sourceRoot":"","sources":["../../src/tools/conversation-archive-enrich-rejection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AASH,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE9C,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,aAAa,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,IAAI,CAAC;IACT,IAAI,EAAE,aAAa,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd;AA4CD,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,qBAAqB,GAC5B,qBAAqB,CAkFvB"}

package/payload/platform/plugins/memory/mcp/dist/tools/conversation-archive-enrich-rejection.js

@@ -0,0 +1,116 @@
+/**
+ * conversation-archive-enrich-rejection MCP tool — Task 980.
+ *
+ * Durable rejection memory for conversation-archive-enrich. Writes to a
+ * sidecar JSONL file alongside the account's state directory; the read side
+ * (filter step) lives in `conversation-archive-derive-insights.ts` so the
+ * path constant has a single source of truth.
+ *
+ * Modes:
+ *   record — append a rejection line. O_APPEND is POSIX-atomic for writes
+ *            ≤ PIPE_BUF; one JSONL line is well under that, so concurrent
+ *            appends never corrupt the file.
+ *   undo   — read all lines, drop matches by (chunkElementId, kind,
+ *            contentHash), then atomic-rename the rewritten file. A `wire`
+ *            of the same key triggers undo so the operator's change of mind
+ *            doesn't leave stale rejections behind.
+ *
+ * Residual race: a `record` append landing between the `undo`'s read and
+ * rename is overwritten. The per-row operator gate is single-threaded
+ * (one chat-turn at a time), so this window is not exploitable in normal
+ * operation. A `flock`-based fix is deferred until rejection volume warrants.
+ */
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { rejectionsJsonlPath, rejectionKey, } from "./conversation-archive-derive-insights.js";
+function readAllLines(path) {
+    if (!existsSync(path))
+        return [];
+    const raw = readFileSync(path, "utf8");
+    return raw.split("\n").filter((line) => line.trim().length > 0);
+}
+function countMatches(lines, chunkElementId, kind, contentHash) {
+    const target = rejectionKey(chunkElementId, kind, contentHash);
+    let n = 0;
+    for (const line of lines) {
+        try {
+            const obj = JSON.parse(line);
+            if (typeof obj.chunkElementId === "string" &&
+                typeof obj.kind === "string" &&
+                typeof obj.contentHash === "string" &&
+                rejectionKey(obj.chunkElementId, obj.kind, obj.contentHash) === target) {
+                n += 1;
+            }
+        }
+        catch {
+            // Parse failure here is a counting concern, not a correctness one —
+            // the filter side already emits rejection-parse-skip.
+        }
+    }
+    return n;
+}
+export function conversationArchiveEnrichRejection(params) {
+    const { accountId, archiveElementId, chunkElementId, kind, contentHash, mode, sessionId, } = params;
+    const path = rejectionsJsonlPath(accountId);
+    mkdirSync(dirname(path), { recursive: true });
+    const before = readAllLines(path);
+    const beforeCount = countMatches(before, chunkElementId, kind, contentHash);
+    if (mode === "record") {
+        if (beforeCount > 0) {
+            // Idempotent: a second `record` for the same key is a silent no-op.
+            process.stderr.write(`[conversation-archive-enrich] rejected chunk=${chunkElementId} kind=${kind} contentHash=${contentHash} stored (already-present)\n`);
+            return { ok: true, mode, beforeCount, afterCount: beforeCount, path };
+        }
+        const line = {
+            archiveElementId,
+            chunkElementId,
+            kind,
+            contentHash,
+            rejectedAt: new Date().toISOString(),
+            rejectedBySession: sessionId ?? null,
+        };
+        appendFileSync(path, JSON.stringify(line) + "\n");
+        process.stderr.write(`[conversation-archive-enrich] rejected chunk=${chunkElementId} kind=${kind} contentHash=${contentHash} stored\n`);
+        return { ok: true, mode, beforeCount, afterCount: beforeCount + 1, path };
+    }
+    // mode === "undo"
+    if (beforeCount === 0) {
+        return { ok: true, mode, beforeCount: 0, afterCount: 0, path };
+    }
+    const target = rejectionKey(chunkElementId, kind, contentHash);
+    const remaining = [];
+    for (const line of before) {
+        try {
+            const obj = JSON.parse(line);
+            if (typeof obj.chunkElementId === "string" &&
+                typeof obj.kind === "string" &&
+                typeof obj.contentHash === "string" &&
+                rejectionKey(obj.chunkElementId, obj.kind, obj.contentHash) === target) {
+                continue;
+            }
+            remaining.push(line);
+        }
+        catch {
+            // Preserve malformed lines through undo — corruption is the filter
+            // side's problem to surface, not this tool's to silently drop.
+            remaining.push(line);
+        }
+    }
+    const tmp = path + ".tmp";
+    writeFileSync(tmp, remaining.length ? remaining.join("\n") + "\n" : "");
+    renameSync(tmp, path);
+    process.stderr.write(`[conversation-archive-enrich] rejection-undone chunk=${chunkElementId} kind=${kind} contentHash=${contentHash}\n`);
+    // The filter loop above removes EVERY matching line, not just one. Under
+    // the residual record-vs-undo race documented at the top of this file, a
+    // single key can briefly have multiple JSONL lines; afterCount must reflect
+    // the actual remaining count for that key (always 0 after a successful
+    // undo) rather than `beforeCount - 1` (only correct when beforeCount==1).
+    return {
+        ok: true,
+        mode,
+        beforeCount,
+        afterCount: 0,
+        path,
+    };
+}
+//# sourceMappingURL=conversation-archive-enrich-rejection.js.map

package/payload/platform/plugins/memory/mcp/dist/tools/conversation-archive-enrich-rejection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-archive-enrich-rejection.js","sourceRoot":"","sources":["../../src/tools/conversation-archive-enrich-rejection.ts"],"names":[],"mappings":"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"}

package/payload/platform/plugins/memory/skills/conversation-archive-enrich/SKILL.md

@@ -0,0 +1,159 @@
+---
+name: conversation-archive-enrich
+description: Source-agnostic Phase 2 for any `:ConversationArchive` — walks the `:Section:Conversation` chunks of one named archive and asks the operator to confirm derived claims row-by-row. Fires only when the operator names a specific archive and asks for insights/enrichment; never auto-fires on Phase 1 completion. Per-row gate (wire / skip / reject) over four kinds — `mention`, `task`, `preference`, `observed-relationship`. Re-runs are idempotent on `(elementId(chunk), kind, contentHash)`, so collapsing duplicates is structural. Invokes the read-only MCP tool `mcp__memory__conversation-archive-derive-insights` to obtain proposals; never writes from the tool's return path. Each `wire` decision runs the proposal's returned `mergeCypher` via `mcp__graph__maxy-graph-write_neo4j_cypher`, or, for `task`, mints the `:Task` via `mcp__tasks__task-create` first and then runs the REFERENCES merge.
+---
+
+# Conversation Archive — chunk-anchored insight derivation
+
+One skill. Walks one `:ConversationArchive`'s chunks in pages. Per chunk, Haiku surfaces high-confidence claims via `mcp__memory__conversation-archive-derive-insights`; per claim, the operator decides `wire / skip / reject`. The tool is read-only; the only writes happen through this skill's per-row dispatch.
+
+## When to invoke
+
+When the operator names a specific archive AND asks for insights, enrichment, or derived claims against it. Concrete triggers:
+
+- "Derive insights from the Adam Mackay WhatsApp archive."
+- "Enrich the Joel × Adam conversation archive — surface anything actionable."
+- "Run Phase 2 on `:ConversationArchive elementId=4:abcd…:42`."
+
+Never auto-fire after a Phase 1 ingest completes — `conversation-archive` (the ingest skill) explicitly writes ZERO observations. Phase 2 is operator-gated by design.
+
+## Resolve the archive
+
+Operator phrasing usually names participants or the source file, not an `elementId`. Resolve via `mcp__memory__memory-search`:
+
+```
+memory-search { query: "<operator's phrasing>", labels: ["ConversationArchive"], expandHops: 0 }
+```
+
+If multiple `:ConversationArchive` rows match, ask the operator to pick by `title` (DM and group archives have stable titles per the predecessor task). If zero match, surface the empty result and yield — never run Phase 2 against the wrong archive.
+
+## Walk the chunks in pages
+
+Page through the chunks with the read-only MCP tool. Default page size is 5 chunks.
+
+```
+mcp__memory__conversation-archive-derive-insights {
+  archiveElementId: "<elementId>",
+  chunkOffset: 0,
+  chunkLimit: 5,
+}
+```
+
+The tool returns:
+
+- A header line with `totalChunks`, `walked=from..to`, `proposalsRemaining`.
+- Zero or more `Proposal N/M` blocks, each carrying `chunkElementId`, `kind`, `contentHash`, `evidenceSnippet`, `proposedAction`, `mergeCypher`, `mergeParams`, and (for `mention` / `observed-relationship`) `resolve:` hints for the operator-confirmed entity resolution.
+
+After processing the page's proposals, advance `chunkOffset` by the page size and re-call until `proposalsRemaining=false`. Empty chunks (no high-confidence claims) are silent — the tool already filtered them.
+
+## Per-row gate
+
+Surface one operator question per proposal. The operator decides `wire`, `skip`, or `reject`. **No batch-confirm.** The doctrine is row-by-row review.
+
+Message shape:
+
+```
+Chunk K/N — kind=<X> — evidence: "<snippet>"
+Proposed: <proposedAction>
+wire / skip / reject ?
+```
+
+Operator answers `wire`, `skip`, or `reject`. Anything else: re-ask the same question.
+
+## On `wire`
+
+Dispatch per kind. Provenance (`createdByTool`, `createdBySession`, `createdAt`) is baked into the proposal's `mergeCypher`; the skill only provides the resolved entity elementIds and the optional `:Task` elementId.
+
+### `mention`
+
+The proposal carries `disambiguation.needsResolution[0]` naming the entity to resolve.
+
+1. Resolve via `mcp__memory__memory-search { query: "<displayName>", labels: ["Person", "Organization"], expandHops: 0 }`.
+2. If multiple candidates: ask the operator to pick by `elementId`. If zero candidates: ask the operator `mint via contact-create / reject`. Minting goes through `mcp__contacts__contact-create` (operator-confirmed canonical Person/Organization — never auto-mint).
+3. Run the `mergeCypher` via `mcp__graph__maxy-graph-write_neo4j_cypher` with `mergeParams` plus `targetElementId=<resolved elementId>`.
+
+A re-run against the same `(chunkElementId, target, contentHash)` collapses on the MERGE — no duplicate edges.
+
+### `task`
+
+1. Mint the `:Task` via `mcp__tasks__task-create` with `title=mergeParams.taskTitle`, optional due hint from `mergeParams.taskDueHint`, `affects=archiveElementId`, `raisedDuringConversationKey=chunkElementId`.
+2. Run the proposal's `mergeCypher` via `mcp__graph__maxy-graph-write_neo4j_cypher` with `mergeParams` plus `taskElementId=<minted Task elementId>`.
+
+The `:Task` itself is the durable artefact; the `REFERENCES` edge to the chunk records the evidence that produced it.
+
+### `preference`
+
+No disambiguation step — the `:Preference` node is account-scoped and MERGE-keyed on `(accountId, contentHash)`. Run the proposal's `mergeCypher` directly via `mcp__graph__maxy-graph-write_neo4j_cypher` with `mergeParams` (no additional substitutions).
+
+The `mergeCypher` MERGEs the `:Preference`, sets category/key/value on first create, and creates the `(:Preference)-[:OBSERVED_IN]->(chunk)` edge that ties the preference to its evidence.
+
+### `observed-relationship`
+
+Two-entity resolution. The proposal carries `disambiguation.needsResolution` with `subject` and `object`.
+
+1. Resolve each via `mcp__memory__memory-search` as in `mention`. Reject the proposal if either entity does not resolve and the operator declines to mint via `contact-create`.
+2. Run the `mergeCypher` with `mergeParams` plus `subjectElementId=<resolved>` and `objectElementId=<resolved>`.
+
+The merged `:RELATED_TO` edge carries `operatorConfirmed: true` so downstream queries can filter speculative relationships out.
+
+## On `skip` or `reject`
+
+`skip` — the operator wants to move on without writing. Note locally and continue. Skips are not persisted; the proposal re-surfaces on the next run.
+
+`reject` — the operator deems the claim wrong. Call `mcp__memory__conversation-archive-enrich-rejection` with `mode: "record"` and the proposal's `chunkElementId`, `kind`, `contentHash`, `archiveElementId`. The tool appends a line to the account's `data/accounts/<accountId>/state/conversation-archive-enrich-rejections.jsonl` sidecar; on every subsequent walk the `conversation-archive-derive-insights` tool filters proposals matching any recorded `(chunkElementId, kind, contentHash)` tuple. Duplicate `record` calls for the same key are silent no-ops.
+
+## Wire undoes prior rejection
+
+After a successful `wire` (any kind), call `mcp__memory__conversation-archive-enrich-rejection` with `mode: "undo"` and the same `(chunkElementId, kind, contentHash)` triple. Operators who change their minds and wire a once-rejected claim should not have to manage rejection state by hand — the wire-then-undo pairing keeps the JSONL aligned with the live graph. Calling `undo` for a key that was never rejected is a silent no-op (`beforeCount=0, afterCount=0`).
+
+## Observability
+
+Per the spec, the tool already emits:
+
+- `[conversation-archive-derive-insights] start accountId=<…> archiveElementId=<…> offset=<n> limit=<n> totalChunks=<N>`
+- `[conversation-archive-derive-insights] chunk=<i>/<N> proposals=<k> elementId=<…> rejections-filtered=<r>` (the `rejections-filtered` field counts proposals dropped by the rejection sidecar this page; field absence = filter not wired)
+- `[conversation-archive-derive-insights] FAIL phase=<haiku|…> reason="..."` (per failing chunk; failures do not abort the walk)
+- `[conversation-archive-derive-insights] done accountId=<…> archiveElementId=<…> walked=<n> proposals=<n> emptyChunks=<n> ms=<n>`
+
+The rejection tool emits one line per write/undo (and one per parse-skip / load-fail when the JSONL is malformed):
+
+- `[conversation-archive-enrich] rejected chunk=<eid> kind=<k> contentHash=<sha> stored` — new rejection appended (or `stored (already-present)` for an idempotent duplicate)
+- `[conversation-archive-enrich] rejection-undone chunk=<eid> kind=<k> contentHash=<sha>` — rejection removed after a wire
+- `[conversation-archive-enrich] rejection-parse-skip line=<n>` — corrupt JSONL line dropped during a walk-time load
+- `[conversation-archive-enrich] rejection-load-fail accountId=<…> reason="…"` — JSONL read errored; walk continues with an empty filter set
+
+The skill itself emits one operator-facing line per row decision:
+
+- `[conversation-archive-enrich] chunk=<i>/<N> kind=<X> action=<wired|skipped|rejected> elementId=<chunkElementId>`
+
+And one end-of-walk summary:
+
+- `[conversation-archive-enrich] done archiveElementId=<…> wired=<n> skipped=<n> rejected=<n> ms=<n>`
+
+## Failure paths
+
+- **`archive-not-found`** — the named elementId did not resolve, or the archive has zero `:Section:Conversation` chunks. LOUD-FAIL surfaced verbatim; the skill yields back to admin. Never silently substitute a different archive.
+- **`haiku` per-chunk fail** — Haiku call failed (rate-limit, network, malformed). The tool continues to the next chunk; the operator sees a `FAIL phase=haiku chunk=i/N` line. Once the page finishes, the skill can be re-invoked with the same `chunkOffset` to retry only the failed chunks.
+- **Entity resolution zero-or-multi** — handled inline in the per-row flow above. Never auto-resolve.
+
+## Verification (post-enrich)
+
+Run via `mcp__graph__maxy-graph-read_neo4j_cypher`:
+
+- All wired writes carry `createdByTool='conversation-archive-derive-insights'`. Count per kind:
+  ```
+  MATCH (c:Section:Conversation)-[m:MENTIONS]->()
+  WHERE m.createdByTool = 'conversation-archive-derive-insights'
+    AND elementId(c) IN $chunkElementIds
+  RETURN count(m)
+  ```
+  (Repeat for `:Task -[:REFERENCES]->`, `:Preference -[:OBSERVED_IN]->`, and `:RELATED_TO`.)
+
+- Idempotency: re-running this skill against the same archive (with the same operator decisions) MUST NOT increase any of the above counts — every MERGE collapses on `contentHash`.
+
+## What this is not
+
+- **Not** an automatic step. The operator names the archive and asks for Phase 2; the skill runs.
+- **Not** a batch-confirm UI. Per-row gate is doctrine; do not synthesise a "wire all visible mentions" shortcut.
+- **Not** a numeric-confidence filter. The Haiku prompt absorbs the confidence floor as a hedging-avoidance instruction — never trust a model-emitted confidence score in code.
+- **Not** a writer of `:Observation` umbrella nodes. The four kinds carry their own provenance via `createdByTool` + `chunkElementId` + `contentHash`; there is no umbrella label.

package/payload/platform/templates/specialists/agents/database-operator.md

@@ -3,7 +3,7 @@ name: database-operator
 description: "Owner of the memory graph — any raw cypher (read or write) against Neo4j routes here, plus all document and archive ingestion (running the universal `document-ingest` skill for unstructured documents — PDF, text, transcript, web page, audio, video — and per-source archive-import skills — LinkedIn Basic Data Export today; CRM-type seed archives as each plugin ships), plus operator-driven graph hygiene (prune orphans, deduplicate entities, add edges, normalise labels), plus one-off raw reads (property-name lookups, edge-shape audits, multi-statement queries) when admin's wrapped read tools — `memory-search`, `memory-rank`, `conversation-search`, `profile-read` — do not expose the property or relationship being asked about. Delegate when the operator uploads any document, drops an archive directory into chat, asks for any graph operation that is not a routine per-turn wrapped write, or asks a factual question whose answer requires a property or relationship admin's wrapped read tools cannot reach."
 summary: "Ingests every unstructured document and external archive into your graph (LinkedIn today; other CRM sources in future) and handles ad-hoc graph tidy-ups on request. For example, when you upload a CV, a pricing guide, or a contract; when you drop a LinkedIn export folder into chat; or when you ask to prune orphan nodes, merge duplicate people, or add edges between entities."
 model: claude-sonnet-4-6
-tools: Read, Bash, Glob, Grep, mcp__graph__maxy-graph-read_neo4j_cypher, mcp__graph__maxy-graph-write_neo4j_cypher, mcp__graph__maxy-graph-get_neo4j_schema, mcp__memory__memory-write, mcp__memory__memory-update, mcp__memory__memory-delete, mcp__memory__memory-search, mcp__memory__memory-rank, mcp__memory__memory-reindex, mcp__memory__memory-find-candidates, mcp__memory__memory-ingest, mcp__memory__memory-ingest-extract, mcp__memory__memory-ingest-web, mcp__memory__memory-classify, mcp__memory__memory-archive-write, mcp__memory__graph-prune-denylist-list, mcp__memory__graph-prune-denylist-add, mcp__memory__graph-prune-denylist-remove, mcp__contacts__contact-create, mcp__contacts__contact-update, mcp__contacts__contact-lookup, mcp__contacts__contact-list, mcp__tasks__task-create, mcp__admin__file-attach, mcp__admin__plugin-read
+tools: Read, Bash, Glob, Grep, mcp__graph__maxy-graph-read_neo4j_cypher, mcp__graph__maxy-graph-write_neo4j_cypher, mcp__graph__maxy-graph-get_neo4j_schema, mcp__memory__memory-write, mcp__memory__memory-update, mcp__memory__memory-delete, mcp__memory__memory-search, mcp__memory__memory-rank, mcp__memory__memory-reindex, mcp__memory__memory-find-candidates, mcp__memory__memory-ingest, mcp__memory__memory-ingest-extract, mcp__memory__memory-ingest-web, mcp__memory__memory-classify, mcp__memory__memory-archive-write, mcp__memory__conversation-archive-derive-insights, mcp__memory__conversation-archive-enrich-rejection, mcp__memory__graph-prune-denylist-list, mcp__memory__graph-prune-denylist-add, mcp__memory__graph-prune-denylist-remove, mcp__contacts__contact-create, mcp__contacts__contact-update, mcp__contacts__contact-lookup, mcp__contacts__contact-list, mcp__tasks__task-create, mcp__admin__file-attach, mcp__admin__plugin-read
 ---
 
 # Database Operator
@@ -119,7 +119,8 @@ The classifier maps document sections to typed ontology labels. It does not inve
 Per-source archive imports keep their own skill because their CSVs already encode entity types deterministically and need no LLM classifier. Currently shipped:
 
 - **linkedin-import** — LinkedIn Basic Data Export. Ships with references for `Profile.csv` and `Connections.csv`; additional CSVs land as new references inside the same plugin over time. Path: `platform/plugins/linkedin-import/skills/linkedin-import/SKILL.md`. Load via `plugin-read` before any ingestion.
-- **conversation-archive** — Conversation transcripts (any source) ingest via the `conversation-archive` skill. One skill, one bash entry, one writer, with `--source <enum>` selecting the per-source normaliser (`whatsapp`, `telegram`, `signal`, `linkedin-messages`, `zoom-transcript`, `meeting-minutes`, `imessage`, `slack`, `other`). Phase 0 ships only `whatsapp`; other normalisers land per-source. Pipeline: operator confirms owner + every distinct sender → `bash platform/plugins/memory/bin/conversation-archive-ingest.sh <archive> --source <enum> --owner-element-id <id> --participant-person-ids <id1>,<id2>,... --scope <admin|public>`. The script normalises (per source), sessionizes at gap-hours boundaries (default 12h), classifies each session via Haiku (`memory-classify` with `mode='chat'`) into topic-bounded `:Section:Conversation` chunks, and writes them under a parent `:ConversationArchive` MERGEd on `conversationIdentity = sha256(accountId + ":" + sortedParticipantElementIds)`. Re-imports are delta-append; the writer is bound to the operator-confirmed sender set (parser-miss = LOUD-FAIL). SKILL: `platform/plugins/memory/skills/conversation-archive/SKILL.md`. Phase 2 insight derivation against chunks is a separate follow-up task. Distinct from the live `whatsapp` plugin (Baileys QR pairing, in-memory store).
+- **conversation-archive** — Conversation transcripts (any source) ingest via the `conversation-archive` skill. One skill, one bash entry, one writer, with `--source <enum>` selecting the per-source normaliser (`whatsapp`, `telegram`, `signal`, `linkedin-messages`, `zoom-transcript`, `meeting-minutes`, `imessage`, `slack`, `other`). Phase 0 ships only `whatsapp`; other normalisers land per-source. Pipeline: operator confirms owner + every distinct sender → `bash platform/plugins/memory/bin/conversation-archive-ingest.sh <archive> --source <enum> --owner-element-id <id> --participant-person-ids <id1>,<id2>,... --scope <admin|public>`. The script normalises (per source), sessionizes at gap-hours boundaries (default 12h), classifies each session via Haiku (`memory-classify` with `mode='chat'`) into topic-bounded `:Section:Conversation` chunks, and writes them under a parent `:ConversationArchive` MERGEd on `conversationIdentity = sha256(accountId + ":" + sortedParticipantElementIds)`. Re-imports are delta-append; the writer is bound to the operator-confirmed sender set (parser-miss = LOUD-FAIL). SKILL: `platform/plugins/memory/skills/conversation-archive/SKILL.md`. Distinct from the live `whatsapp` plugin (Baileys QR pairing, in-memory store).
+- **conversation-archive-enrich** — Phase 2 over a named `:ConversationArchive`. Source-agnostic — runs against any archive produced by the `conversation-archive` skill regardless of source. Operator-triggered only (never auto-fires on Phase 1 completion). Walks `:Section:Conversation` chunks in pages via the read-only MCP tool `mcp__memory__conversation-archive-derive-insights` (which calls Haiku per chunk on OAuth, NOT the API key) and surfaces high-confidence claims for per-row operator gate (`wire / skip / reject`) over four kinds — `mention`, `task`, `preference`, `observed-relationship`. Idempotent on `(elementId(chunk), kind, contentHash)`: re-runs collapse identical claims via MERGE. Load: `platform/plugins/memory/skills/conversation-archive-enrich/SKILL.md`. Trigger phrasing: operator names a specific archive AND asks for insights / enrichment / derived claims — never the ingest skill's completion event.
 
 Future CRM-type seed plugins (HubSpot, Salesforce, Pipedrive, iCloud contacts, Gmail CSV, etc.) will ship under the same pattern — each as its own opt-in plugin, each with its own `SKILL.md` path under `platform/plugins/<name>/skills/`. When the admin adds a new archive-import skill, its PLUGIN.md will name itself here and in the admin's `<plugin-manifest>`. No prompt change required.