@ouro.bot/cli 0.1.0-alpha.92 → 0.1.0-alpha.920

package/dist/mind/friend-link-codes.js

@@ -0,0 +1,209 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_LINK_CODE_TTL_MS = void 0;
+exports.parseLinkCode = parseLinkCode;
+exports.formatLinkCode = formatLinkCode;
+exports.issueLinkCode = issueLinkCode;
+exports.redeemLinkCode = redeemLinkCode;
+// Identity link codes: how a person proves that a new channel identity is theirs.
+//
+// A friend on a surface the agent already trusts (the owner's CLI, or a family chat)
+// asks for a short code. When that exact code arrives as a 1:1 message from an
+// identity the agent does not yet trust, that identity's record merges into the
+// friend who asked, and the new identity is treated as them from then on.
+//
+// Codes are single use and expire. Only a SHA-256 digest of each code is stored, under
+// the agent's `state/` directory, which bundle sync does not carry. A code is consumed
+// by its first presentation, whatever the outcome, by an atomic rename, so a replay or a
+// race between two senders finds nothing to redeem.
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const runtime_1 = require("../nerves/runtime");
+const friend_merge_1 = require("./friend-merge");
+const CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+const CODE_BODY_LENGTH = 8;
+exports.DEFAULT_LINK_CODE_TTL_MS = 10 * 60 * 1000;
+const MAX_LINK_CODE_TTL_MS = 24 * 60 * 60 * 1000;
+const CODE_SHAPE = new RegExp(`^OURO-?([${CODE_ALPHABET}]{4})-?([${CODE_ALPHABET}]{4})$`);
+function codesRoot(agentRoot) {
+    return path.join(agentRoot, "state", "friend-link-codes");
+}
+function digest(codeBody) {
+    return (0, node_crypto_1.createHash)("sha256").update(codeBody).digest("hex");
+}
+/**
+ * The code body when `text` is exactly one link code (case, spacing, dashes and simple
+ * markup ignored), otherwise null. Anything else in the message means it is not a code.
+ */
+function parseLinkCode(text) {
+    const plain = text
+        .replace(/<at>[^<]*<\/at>/gi, " ")
+        .replace(/<[^>]*>/g, " ")
+        .replace(/&nbsp;/g, " ")
+        .replace(/\s+/g, "")
+        .toUpperCase();
+    const match = CODE_SHAPE.exec(plain);
+    return match ? `${match[1]}${match[2]}` : null;
+}
+function formatLinkCode(codeBody) {
+    return `OURO-${codeBody.slice(0, 4)}-${codeBody.slice(4)}`;
+}
+function issueLinkCode(input) {
+    const now = (input.now ?? (() => new Date()))();
+    const ttlMs = Math.min(Math.max(input.ttlMs ?? exports.DEFAULT_LINK_CODE_TTL_MS, 60 * 1000), MAX_LINK_CODE_TTL_MS);
+    let codeBody = "";
+    for (let index = 0; index < CODE_BODY_LENGTH; index += 1)
+        codeBody += CODE_ALPHABET[(0, node_crypto_1.randomInt)(CODE_ALPHABET.length)];
+    const record = {
+        schemaVersion: 1,
+        friendId: input.friend.id,
+        friendName: input.friend.name,
+        ...(input.channel ? { channel: input.channel } : {}),
+        issuedAt: now.toISOString(),
+        expiresAt: new Date(now.getTime() + ttlMs).toISOString(),
+        issuedBy: input.issuedBy,
+    };
+    const pendingDir = path.join(codesRoot(input.agentRoot), "pending");
+    fs.mkdirSync(pendingDir, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(path.join(pendingDir, `${digest(codeBody)}.json`), `${JSON.stringify(record, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+    (0, runtime_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.link_code_issued",
+        message: "issued an identity link code",
+        meta: { friendId: input.friend.id, channel: input.channel ?? "any", expiresAt: record.expiresAt, issuedBy: input.issuedBy },
+    });
+    return { code: formatLinkCode(codeBody), friendId: record.friendId, friendName: record.friendName, ...(record.channel ? { channel: record.channel } : {}), expiresAt: record.expiresAt };
+}
+const REJECTION_REPLIES = {
+    unknown_or_used: "That link code isn't valid. Ask for a new one.",
+    expired: "That link code has expired. Ask for a new one.",
+    group_chat: "Link codes only work in a 1:1 chat with me. Ask for a new code and send it to me directly.",
+    wrong_channel: "That link code was issued for a different channel. Ask for a new one.",
+    already_linked: "This account is already linked to you.",
+    claimant_trusted: "This account is already known to me as someone I trust, so a code can't relink it. The owner can merge the records instead.",
+    friend_missing: "The person this code was issued for no longer exists. Ask for a new code.",
+};
+function reject(reason, meta) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "friends",
+        event: "friends.link_code_rejected",
+        message: "rejected an identity link code",
+        meta: { reason, ...meta },
+    });
+    return { status: "rejected", reason, reply: REJECTION_REPLIES[reason] };
+}
+/** Atomically take the code out of `pending/`. Null when no pending code has this body. */
+function consumeCode(agentRoot, codeBody, nowIso) {
+    const root = codesRoot(agentRoot);
+    const name = `${digest(codeBody)}.json`;
+    const usedDir = path.join(root, "used");
+    fs.mkdirSync(usedDir, { recursive: true, mode: 0o700 });
+    const usedPath = path.join(usedDir, name);
+    try {
+        fs.renameSync(path.join(root, "pending", name), usedPath);
+    }
+    catch (error) {
+        /* v8 ignore next -- only ENOENT is expected; other filesystem failures propagate @preserve */
+        if (error.code !== "ENOENT")
+            throw error;
+        return null;
+    }
+    const record = JSON.parse(fs.readFileSync(usedPath, "utf-8"));
+    fs.writeFileSync(usedPath, `${JSON.stringify({ ...record, consumedAt: nowIso }, null, 2)}\n`, { mode: 0o600 });
+    return { record, usedPath };
+}
+function recordOutcome(usedPath, outcome) {
+    const current = JSON.parse(fs.readFileSync(usedPath, "utf-8"));
+    fs.writeFileSync(usedPath, `${JSON.stringify({ ...current, ...outcome }, null, 2)}\n`, { mode: 0o600 });
+}
+/**
+ * Redeem a link code sent by `claimant`. Returns null when `text` is not a link code, so
+ * callers can run this on every inbound message and fall through to a normal turn.
+ */
+async function redeemLinkCode(input) {
+    const codeBody = parseLinkCode(input.text);
+    if (!codeBody)
+        return null;
+    const now = (input.now ?? (() => new Date()))();
+    const nowIso = now.toISOString();
+    const baseMeta = { claimantId: input.claimant.id, channel: input.channel };
+    const consumed = consumeCode(input.agentRoot, codeBody, nowIso);
+    if (!consumed)
+        return reject("unknown_or_used", baseMeta);
+    const { record, usedPath } = consumed;
+    const meta = { ...baseMeta, friendId: record.friendId };
+    const refuse = (reason) => {
+        recordOutcome(usedPath, { outcome: "rejected", reason, claimantId: input.claimant.id, channel: input.channel });
+        return reject(reason, meta);
+    };
+    if (Date.parse(record.expiresAt) <= now.getTime())
+        return refuse("expired");
+    if (input.isGroupChat)
+        return refuse("group_chat");
+    if (record.channel && record.channel !== input.channel)
+        return refuse("wrong_channel");
+    if (input.claimant.id === record.friendId)
+        return refuse("already_linked");
+    // A code can only bring in an identity the agent does not already trust; trusted
+    // records are merged deliberately by the owner, not by whoever holds a code.
+    if (input.claimant.trustLevel !== "stranger" && input.claimant.trustLevel !== "acquaintance")
+        return refuse("claimant_trusted");
+    const merged = await (0, friend_merge_1.mergeFriends)({
+        store: input.store,
+        friendsDir: input.friendsDir,
+        targetId: record.friendId,
+        sourceIds: [input.claimant.id],
+        actor: `link-code:${record.issuedBy}`,
+        reason: `identity link code redeemed on ${input.channel}`,
+        now: () => now,
+    });
+    if (!merged.ok)
+        return refuse("friend_missing");
+    recordOutcome(usedPath, { outcome: "linked", claimantId: input.claimant.id, channel: input.channel, linkedExternalIds: merged.addedExternalIds.map((externalId) => externalId.provider) });
+    (0, runtime_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.link_code_redeemed",
+        message: "linked a new identity through a link code",
+        meta: { ...meta, trustLevel: merged.target.trustLevel, linkedExternalIds: merged.addedExternalIds.map((externalId) => externalId.provider) },
+    });
+    return {
+        status: "linked",
+        friend: merged.target,
+        reply: `Linked. I'll recognize this ${input.channel} account as ${merged.target.name} from now on.`,
+    };
+}

package/dist/mind/friend-merge.js

@@ -0,0 +1,330 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.externalIdKey = externalIdKey;
+exports.mergeFriendRecordContent = mergeFriendRecordContent;
+exports.mergeFriends = mergeFriends;
+exports.planFriendDedupe = planFriendDedupe;
+exports.dedupeFriends = dedupeFriends;
+// Merging friend records into one person, and retiring the merged-away records.
+//
+// Two product paths use this: redeeming an identity link code (a new channel identity
+// joins its owner's record) and deduplicating records that name the same local person.
+// The target record stays authoritative: a merge never raises trust, admission,
+// initiative or capability, so merging cannot be used to escalate anyone.
+//
+// A retired record is kept as a tombstone in `friends/_retired/` (outside the store's
+// listing), never deleted silently. External-identity claim journals that pointed at the
+// retired record move beside it, so the store's claim ledger never names a record that
+// no longer exists. The claim journal layout belongs to @ouro.bot/friends; this module
+// only moves whole journal files and never rewrites them.
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../nerves/runtime");
+const RETIRED_DIR = "_retired";
+const CLAIMS_DIR = "_external-id-claims";
+const CLAIM_FILE = /^[a-f0-9]{64}\.json$/;
+function externalIdKey(externalId) {
+    return JSON.stringify([externalId.provider, externalId.externalId, externalId.tenantId ?? null]);
+}
+/** Fold the sources into the target. The target's relationship fields always win. */
+function mergeFriendRecordContent(target, sources, nowIso) {
+    const externalIds = [...target.externalIds];
+    const seenIds = new Set(externalIds.map(externalIdKey));
+    const addedExternalIds = [];
+    const notes = { ...target.notes };
+    const preservedNoteKeys = [];
+    const tenantMemberships = [...target.tenantMemberships];
+    const toolPreferences = { ...target.toolPreferences };
+    const connections = [...(target.connections ?? [])];
+    const importedNotes = { ...(target.importedNotes ?? {}) };
+    let totalTokens = target.totalTokens;
+    let createdAt = target.createdAt;
+    for (const source of sources) {
+        for (const externalId of source.externalIds) {
+            const key = externalIdKey(externalId);
+            if (seenIds.has(key))
+                continue;
+            seenIds.add(key);
+            externalIds.push(externalId);
+            addedExternalIds.push(externalId);
+        }
+        for (const [key, note] of Object.entries(source.notes)) {
+            const existing = notes[key];
+            if (!existing) {
+                notes[key] = note;
+                continue;
+            }
+            if (existing.value === note.value)
+                continue;
+            const preservedKey = `${key}~${source.id.slice(0, 8)}`;
+            if (notes[preservedKey])
+                continue;
+            notes[preservedKey] = note;
+            preservedNoteKeys.push(preservedKey);
+        }
+        for (const tenant of source.tenantMemberships) {
+            if (!tenantMemberships.includes(tenant))
+                tenantMemberships.push(tenant);
+        }
+        for (const [tool, preference] of Object.entries(source.toolPreferences)) {
+            if (!(tool in toolPreferences))
+                toolPreferences[tool] = preference;
+        }
+        for (const connection of source.connections ?? []) {
+            if (!connections.some((known) => known.name === connection.name && known.relationship === connection.relationship)) {
+                connections.push(connection);
+            }
+        }
+        for (const [agentKey, imported] of Object.entries(source.importedNotes ?? {})) {
+            importedNotes[agentKey] = { ...imported, ...(importedNotes[agentKey] ?? {}) };
+        }
+        totalTokens += source.totalTokens;
+        if (source.createdAt < createdAt)
+            createdAt = source.createdAt;
+    }
+    const merged = {
+        ...target,
+        externalIds,
+        notes,
+        tenantMemberships,
+        toolPreferences,
+        connections,
+        ...(Object.keys(importedNotes).length > 0 ? { importedNotes } : {}),
+        totalTokens,
+        createdAt,
+        updatedAt: nowIso,
+    };
+    return { merged, addedExternalIds, preservedNoteKeys };
+}
+function writePrivateJson(filePath, value) {
+    const temp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(temp, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(temp, filePath);
+}
+function uniqueTombstonePath(retiredDir, friendId, nowIso) {
+    const plain = path.join(retiredDir, `${friendId}.json`);
+    if (!fs.existsSync(plain))
+        return plain;
+    return path.join(retiredDir, `${friendId}.${nowIso.replace(/[:.]/g, "-")}.json`);
+}
+/** Move every claim journal that names `friendId` out of the live claim ledger. */
+function moveClaimJournals(friendsDir, friendId) {
+    const claimsDir = path.join(friendsDir, CLAIMS_DIR);
+    if (!fs.existsSync(claimsDir))
+        return [];
+    const retiredClaimsDir = path.join(friendsDir, RETIRED_DIR, "external-id-claims");
+    const moved = [];
+    for (const entry of fs.readdirSync(claimsDir)) {
+        if (!CLAIM_FILE.test(entry))
+            continue;
+        let claim;
+        try {
+            claim = JSON.parse(fs.readFileSync(path.join(claimsDir, entry), "utf-8"));
+        }
+        catch {
+            continue;
+        }
+        if (claim.friendId !== friendId)
+            continue;
+        fs.mkdirSync(retiredClaimsDir, { recursive: true, mode: 0o700 });
+        fs.renameSync(path.join(claimsDir, entry), path.join(retiredClaimsDir, entry));
+        moved.push(entry);
+    }
+    return moved;
+}
+async function mergeFriends(input) {
+    const nowIso = (input.now ?? (() => new Date()))().toISOString();
+    const dryRun = input.dryRun === true;
+    const sourceIds = [...new Set(input.sourceIds)];
+    if (sourceIds.length === 0 || sourceIds.includes(input.targetId)) {
+        return { ok: false, reason: "invalid_sources", message: "name at least one record to merge, other than the target" };
+    }
+    const target = await input.store.get(input.targetId);
+    if (!target || target.id !== input.targetId) {
+        return { ok: false, reason: "target_not_found", message: `friend not found: ${input.targetId}` };
+    }
+    const sources = [];
+    for (const sourceId of sourceIds) {
+        const source = await input.store.get(sourceId);
+        if (!source || source.id !== sourceId) {
+            return { ok: false, reason: "source_not_found", message: `friend not found: ${sourceId}` };
+        }
+        if ((source.kind ?? "human") !== (target.kind ?? "human")) {
+            return { ok: false, reason: "kind_mismatch", message: `cannot merge ${sourceId} into ${target.id}: an agent and a human are different friends` };
+        }
+        sources.push(source);
+    }
+    const { merged, addedExternalIds, preservedNoteKeys } = mergeFriendRecordContent(target, sources, nowIso);
+    const retiredDir = path.join(input.friendsDir, RETIRED_DIR);
+    if (dryRun) {
+        return {
+            ok: true,
+            dryRun,
+            target: merged,
+            addedExternalIds,
+            preservedNoteKeys,
+            retired: sources.map((source) => ({ friendId: source.id, name: source.name, tombstonePath: path.join(retiredDir, `${source.id}.json`), movedClaims: [] })),
+        };
+    }
+    // Order: tombstones first (nothing is lost if we stop), then the target gains the
+    // identities, then the sources leave the store and their claim journals follow them.
+    fs.mkdirSync(retiredDir, { recursive: true, mode: 0o700 });
+    const tombstones = sources.map((source) => {
+        const tombstonePath = uniqueTombstonePath(retiredDir, source.id, nowIso);
+        writePrivateJson(tombstonePath, {
+            schemaVersion: 1,
+            retiredAt: nowIso,
+            retiredInto: target.id,
+            actor: input.actor,
+            reason: input.reason,
+            record: source,
+        });
+        return { source, tombstonePath };
+    });
+    await input.store.put(target.id, merged);
+    const retired = [];
+    for (const { source, tombstonePath } of tombstones) {
+        await input.store.delete(source.id);
+        const movedClaims = moveClaimJournals(input.friendsDir, source.id);
+        retired.push({ friendId: source.id, name: source.name, tombstonePath, movedClaims });
+        (0, runtime_1.emitNervesEvent)({
+            component: "friends",
+            event: "friends.record_retired",
+            message: "retired a friend record into another record",
+            meta: { friendId: source.id, retiredInto: target.id, actor: input.actor, movedClaims: movedClaims.length },
+        });
+    }
+    const stored = (await input.store.get(target.id)) ?? merged;
+    (0, runtime_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.records_merged",
+        message: "merged friend records",
+        meta: {
+            targetId: target.id,
+            sourceIds,
+            actor: input.actor,
+            reason: input.reason,
+            addedExternalIds: addedExternalIds.map((externalId) => externalId.provider),
+            preservedNoteKeys: preservedNoteKeys.length,
+        },
+    });
+    return { ok: true, dryRun, target: stored, addedExternalIds, preservedNoteKeys, retired };
+}
+function isLocalOnly(record) {
+    return record.externalIds.length > 0 && record.externalIds.every((externalId) => externalId.provider === "local");
+}
+function canonicalOrder(a, b) {
+    const notes = Object.keys(b.notes).length - Object.keys(a.notes).length;
+    if (notes !== 0)
+        return notes;
+    if (a.createdAt !== b.createdAt)
+        return a.createdAt < b.createdAt ? -1 : 1;
+    return a.id < b.id ? -1 : 1;
+}
+/**
+ * Records are duplicates when they are human, carry only local identities, share the
+ * same name and trust level, and are joined through at least one shared local identity.
+ * The canonical record is the one with the most notes, then the oldest.
+ */
+function planFriendDedupe(records) {
+    const buckets = new Map();
+    for (const record of records) {
+        if ((record.kind ?? "human") !== "human" || !isLocalOnly(record))
+            continue;
+        const key = JSON.stringify([record.name.trim().toLowerCase(), record.trustLevel ?? "friend"]);
+        buckets.set(key, [...(buckets.get(key) ?? []), record]);
+    }
+    const groups = [];
+    for (const bucket of buckets.values()) {
+        // Union records that share any local identity.
+        const parent = bucket.map((_, index) => index);
+        const find = (index) => (parent[index] === index ? index : (parent[index] = find(parent[index])));
+        const owner = new Map();
+        bucket.forEach((record, index) => {
+            for (const externalId of record.externalIds) {
+                const key = externalIdKey(externalId);
+                const seen = owner.get(key);
+                if (seen === undefined)
+                    owner.set(key, index);
+                else
+                    parent[find(index)] = find(seen);
+            }
+        });
+        const components = new Map();
+        bucket.forEach((record, index) => {
+            const root = find(index);
+            components.set(root, [...(components.get(root) ?? []), record]);
+        });
+        for (const members of components.values()) {
+            if (members.length < 2)
+                continue;
+            const [canonical, ...duplicates] = [...members].sort(canonicalOrder);
+            groups.push({ canonical: canonical, duplicates });
+        }
+    }
+    return groups.sort((a, b) => canonicalOrder(a.canonical, b.canonical));
+}
+async function dedupeFriends(input) {
+    const listAll = input.store.listAll;
+    const records = listAll ? await listAll.call(input.store) : [];
+    const plan = planFriendDedupe(records);
+    const dryRun = input.dryRun !== false;
+    const groups = [];
+    for (const group of plan) {
+        const duplicateIds = group.duplicates.map((record) => record.id);
+        const result = await mergeFriends({
+            store: input.store,
+            friendsDir: input.friendsDir,
+            targetId: group.canonical.id,
+            sourceIds: duplicateIds,
+            actor: input.actor,
+            reason: "duplicate local records of the same person",
+            dryRun,
+            ...(input.now ? { now: input.now } : {}),
+        });
+        /* v8 ignore next -- the plan only names records it just listed; a concurrent removal is the only way here @preserve */
+        if (!result.ok)
+            throw new Error(result.message);
+        groups.push({ canonical: result.target, duplicateIds, preservedNoteKeys: result.preservedNoteKeys, addedExternalIds: result.addedExternalIds });
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.dedupe_completed",
+        message: dryRun ? "planned friend record dedupe" : "applied friend record dedupe",
+        meta: { dryRun, groups: groups.length, duplicates: groups.reduce((sum, group) => sum + group.duplicateIds.length, 0), actor: input.actor },
+    });
+    return { dryRun, groups };
+}