@indigoai-us/hq-cli 5.312.2-beta.0 → 5.314.0

package/dist/lib/checkpoint-ontology/merge-copies.js

@@ -1,1086 +0,0 @@
-/**
- * Merge numbered entity copies (`<slug> 2.md`) into their original file and
- * delete them (CO-54, owner decision CO-D-007 option 2).
- *
- * Gated by `checkpoint.ontology.merge-copies`. A copy is a file named
- * `<slug> <n>.md` next to `<slug>.md` of the same type, with the same `id`,
- * in one duplicate group. Other members of a group are never touched.
- *
- * Two steps, run separately so sync can push the merged original before its
- * copy goes away:
- *
- * - merge: the copy's fresh aliases, back-references and relationship lines
- *   are added to the original, `signal_count` takes the higher value, and
- *   entity files that link to the copy are re-pointed at the original. Every
- *   rewritten file is recorded in the outbox before it is written, so sync
- *   pushes it. Keys the checkpoint does not own keep the original's value.
- * - delete: a copy is deleted from the vault, by exact key, only when merging
- *   it again would change nothing and no entity file or signal links to it.
- *   The vault keeps every old version. The local file goes after the vault
- *   delete succeeds, or when the vault no longer has the key.
- *
- * Copies of one original merge in path order, each into the result of the
- * previous one, and none of them counts as holding a name the others move.
- * A copy whose body has lines the merged original lacks (prose the merge does
- * not carry) is merged but never deleted. A copy linked from any file the
- * merge cannot rewrite (a copy, a knowledge file, a signal) is held.
- *
- * A signal whose `entity_refs` names a copy holds that copy: signals are
- * server-owned, so the ref cannot be re-pointed from here. With `rewriteRefs`
- * (flag `checkpoint.ontology.merge-rewrite-refs`) invoice and bill links and
- * knowledge links are re-pointed at the survivor and the survivor receives
- * the copy's `external_ids` and `web_domains`. A signal ref or a link from a
- * source still holds the pair (`server_owned_refs`): the sync client cannot
- * push those files. A link from another copy or an external id conflict also
- * holds a pair.
- *
- * With `pairKind: "variants"` (flag `checkpoint.ontology.merge-variants`) the
- * pairs are two-file duplicate groups whose canonical names differ only in
- * case, spacing or punctuation; the survivor is the spaced name, then the
- * higher `signal_count`, then path order. The copy's canonical name becomes
- * an alias of the survivor. Merge and delete work as for numbered copies.
- *
- * With `pairKind: "listed"` (flag `checkpoint.ontology.merge-listed-pairs`)
- * the pairs are exactly the `only` entries, reviewed by a person: no finder
- * runs, so the names may differ. Each entry must name two entities of one
- * type; a copy listed twice, or listed both as a copy and as an original, is
- * skipped as `listed_conflict`. Holds, merge and delete work as for numbered
- * copies.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { isDeepStrictEqual } from "node:util";
-import { freshAliases, ownNames } from "./aliases.js";
-import { entitiesRoot, safeWriteFile } from "./company.js";
-import { appendBackRefs, OWNED_KEYS, parseEntityFile, patchEntityFile, setIdentityKeys } from "./entity-file.js";
-import { isWritableEntityType, normalizeEntityName } from "./identity.js";
-import { findDuplicateGroups, readBackRefs, recordOutbox } from "./multi-writer.js";
-import { buildEntityIndex, listSignalFiles, readSignal } from "./tree.js";
-export const MERGE_COPIES_FLAG = "checkpoint.ontology.merge-copies";
-/**
- * `merge-copies --variants`: merge two-file duplicate groups whose canonical
- * names differ only in spacing, case or punctuation (CO-65).
- */
-export const MERGE_VARIANTS_FLAG = "checkpoint.ontology.merge-variants";
-/** `merge-copies --listed`: merge exactly the reviewed `--only` pairs (CO-74). */
-export const MERGE_LISTED_PAIRS_FLAG = "checkpoint.ontology.merge-listed-pairs";
-/**
- * `merge-copies --rewrite-refs`: re-point signal `entity_refs`, invoice and
- * bill links, source and knowledge links from a copy to its survivor, and
- * carry the copy's `external_ids` and `web_domains` to the survivor.
- */
-export const MERGE_REWRITE_REFS_FLAG = "checkpoint.ontology.merge-rewrite-refs";
-/** `<slug> <n>.md`, the name a file manager gives a second copy. */
-const COPY_NAME = /^(.+) (\d+)\.md$/;
-/** A relationship list item with a link, as the gardener and checkpoint write them. */
-const LINK_ITEM = /^- .*\]\([^)\n]+\)\s*$/;
-const BACKREF_ITEM = /^- Referenced in \[/;
-const MD_LINK = /\]\(([^)\n]+)\)/g;
-/** Keys that differ between copies for reasons that say nothing about content. */
-const IGNORED_KEYS = new Set(["first_seen", "confidence"]);
-function sectionLines(body) {
-    const match = /(^|\n)##\s+Relationships\s*\n([\s\S]*?)(?=\n##\s|$)/.exec(body);
-    return match ? match[2].split(/\r?\n/).map((line) => line.trimEnd()) : [];
-}
-function splitBody(content) {
-    const match = /^(---\r?\n[\s\S]*?\r?\n---\r?\n?)([\s\S]*)$/.exec(content);
-    return match ? { frontmatter: match[1], body: match[2] } : null;
-}
-/**
- * A line of the copy whose every link points at the copy itself or at its
- * original. Moved to the original it would link the survivor to itself or to
- * the file about to be deleted, so it is neither moved nor unmerged content.
- */
-function isPairSelfLine(line, pair) {
-    const targets = [...line.matchAll(MD_LINK)].map((match) => resolveLink(pair.copy, match[1]));
-    return targets.length > 0 && targets.every((target) => target === pair.copy || target === pair.original);
-}
-/** Relationship lines of the copy that the original lacks (back-references and self links excluded). */
-function missingRelationshipLines(originalContent, copyContent, pair) {
-    const original = splitBody(originalContent);
-    const copy = splitBody(copyContent);
-    if (!original || !copy)
-        return [];
-    const have = new Set(original.body.split(/\r?\n/).map((line) => line.trimEnd()));
-    const out = [];
-    for (const line of sectionLines(copy.body)) {
-        if (!LINK_ITEM.test(line) || BACKREF_ITEM.test(line) || have.has(line) || isPairSelfLine(line, pair))
-            continue;
-        have.add(line);
-        out.push(line);
-    }
-    return out;
-}
-/** Append lines to `## Relationships`, creating the section when it is missing. */
-function appendRelationshipLines(content, lines) {
-    if (lines.length === 0)
-        return content;
-    const parts = splitBody(content);
-    const body = parts.body;
-    const section = /(^|\n)(##\s+Relationships\s*\n)([\s\S]*?)(?=\n##\s|\s*$)/.exec(body);
-    let next;
-    if (section) {
-        const before = body.slice(0, section.index + section[1].length);
-        const kept = section[3].replace(/\s+$/, "");
-        const after = body.slice(section.index + section[0].length);
-        next = `${before}${section[2]}${kept ? `${kept}\n${lines.join("\n")}` : lines.join("\n")}\n${after}`;
-    }
-    else {
-        const trimmed = body.replace(/\s+$/, "");
-        next = `${trimmed.length > 0 ? `${trimmed}\n\n` : "\n"}## Relationships\n\n${lines.join("\n")}\n`;
-    }
-    return `${parts.frontmatter}${next}`;
-}
-/** Remove one entity from the name indexes so its names stop counting as taken. */
-function unindex(index, rel) {
-    index.byRel.delete(rel);
-    for (const map of [index.canonical, index.alias, index.squashed]) {
-        for (const [key, rels] of map) {
-            if (!rels.delete(rel))
-                continue;
-            if (rels.size === 0)
-                map.delete(key);
-        }
-    }
-}
-/** Copies in scope, and the ones skipped with a reason. Read-only. */
-export function findCopyPairs(index) {
-    const groupOf = new Map();
-    findDuplicateGroups(index).forEach((group, i) => {
-        for (const rel of group.paths)
-            groupOf.set(rel, i);
-    });
-    const pairs = [];
-    const skipped = [];
-    const candidates = [...index.byRel.values()]
-        .filter((entity) => isWritableEntityType(entity.type) && COPY_NAME.test(path.posix.basename(entity.rel)))
-        .sort((a, b) => a.rel.localeCompare(b.rel));
-    for (const copy of candidates) {
-        const base = COPY_NAME.exec(path.posix.basename(copy.rel))[1];
-        const original = `${path.posix.dirname(copy.rel)}/${base}.md`;
-        const target = index.byRel.get(original);
-        if (!target) {
-            skipped.push({ copy: copy.rel, reason: index.invalid.has(original) ? "original_invalid" : "no_original" });
-        }
-        else if (target.id !== copy.id || target.type !== copy.type) {
-            skipped.push({ copy: copy.rel, reason: "identity_differs" });
-        }
-        else if (groupOf.get(copy.rel) === undefined || groupOf.get(copy.rel) !== groupOf.get(original)) {
-            skipped.push({ copy: copy.rel, reason: "not_in_duplicate_group" });
-        }
-        else {
-            pairs.push({ type: copy.type, copy: copy.rel, original });
-        }
-    }
-    return { pairs, skipped };
-}
-/** The canonical name with case, spacing and punctuation removed. */
-function compactName(name, type) {
-    return normalizeEntityName(name, type).replace(/[^\p{L}\p{N}]/gu, "");
-}
-/**
- * Two-file duplicate groups whose canonical names differ only in case, spacing
- * or punctuation. Numbered copies are left to `findCopyPairs`. Read-only.
- */
-export function findVariantPairs(index) {
-    const pairs = [];
-    const skipped = [];
-    for (const group of findDuplicateGroups(index)) {
-        const paths = [...group.paths].sort((a, b) => a.localeCompare(b));
-        const numbered = paths.filter((rel) => COPY_NAME.test(path.posix.basename(rel)));
-        if (numbered.length > 0) {
-            for (const rel of numbered)
-                skipped.push({ copy: rel, reason: "numbered_copy" });
-            continue;
-        }
-        if (paths.length !== 2) {
-            skipped.push({ copy: paths[0], reason: "group_size" });
-            continue;
-        }
-        const left = index.byRel.get(paths[0]);
-        const right = index.byRel.get(paths[1]);
-        if (!left || !right) {
-            skipped.push({ copy: paths[0], reason: "no_original" });
-            continue;
-        }
-        if (left.type !== right.type) {
-            skipped.push({ copy: paths[0], reason: "type_differs" });
-            continue;
-        }
-        const leftName = compactName(left.canonical_name, left.type);
-        const rightName = compactName(right.canonical_name, right.type);
-        if (leftName === "" || rightName === "" || leftName !== rightName) {
-            skipped.push({ copy: paths[0], reason: "names_differ" });
-            continue;
-        }
-        const leftSpaced = left.canonical_name.includes(" ");
-        const rightSpaced = right.canonical_name.includes(" ");
-        let originalRel = paths[0];
-        let copyRel = paths[1];
-        if (leftSpaced !== rightSpaced) {
-            originalRel = leftSpaced ? paths[0] : paths[1];
-            copyRel = leftSpaced ? paths[1] : paths[0];
-        }
-        else if (left.signal_count !== right.signal_count) {
-            originalRel = left.signal_count > right.signal_count ? paths[0] : paths[1];
-            copyRel = originalRel === paths[0] ? paths[1] : paths[0];
-        }
-        pairs.push({ type: left.type, copy: copyRel, original: originalRel });
-    }
-    pairs.sort((a, b) => a.copy.localeCompare(b.copy));
-    return { pairs, skipped };
-}
-/**
- * The reviewed pairs themselves, for `pairKind: "listed"`. An entry is kept
- * when both files are indexed entities of one writable type. Read-only.
- */
-export function findListedPairs(index, only) {
-    const pairs = [];
-    const skipped = [];
-    const copyCount = new Map();
-    for (const entry of only)
-        copyCount.set(entry.copy, (copyCount.get(entry.copy) ?? 0) + 1);
-    const originals = new Set(only.map((entry) => entry.original));
-    for (const entry of only) {
-        const copy = index.byRel.get(entry.copy);
-        const original = index.byRel.get(entry.original);
-        if (copyCount.get(entry.copy) > 1 || originals.has(entry.copy) || entry.copy === entry.original) {
-            skipped.push({ copy: entry.copy, reason: "listed_conflict" });
-        }
-        else if (!copy || !original) {
-            skipped.push({ copy: entry.copy, reason: index.invalid.has(entry.original) ? "original_invalid" : "no_original" });
-        }
-        else if (copy.type !== original.type || !isWritableEntityType(copy.type)) {
-            skipped.push({ copy: entry.copy, reason: "type_differs" });
-        }
-        else {
-            pairs.push({ type: copy.type, copy: entry.copy, original: entry.original });
-        }
-    }
-    pairs.sort((a, b) => a.copy.localeCompare(b.copy));
-    return { pairs, skipped };
-}
-/** Resolve a relative link in `fromRel` to a company-relative path, or null. */
-function resolveLink(fromRel, href) {
-    if (/^[a-z][a-z0-9+.-]*:/i.test(href) || href.startsWith("#") || href.startsWith("/"))
-        return null;
-    let decoded;
-    try {
-        decoded = decodeURI(href.split("#")[0]);
-    }
-    catch {
-        return null;
-    }
-    const resolved = path.posix.normalize(path.posix.join(path.posix.dirname(fromRel), decoded));
-    return resolved.startsWith("..") ? null : resolved;
-}
-function listEntityFiles(company) {
-    const root = entitiesRoot(company);
-    const out = [];
-    let types;
-    try {
-        types = fs.readdirSync(root, { withFileTypes: true });
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return out;
-        throw error;
-    }
-    for (const type of types.filter((entry) => entry.isDirectory())) {
-        for (const file of fs.readdirSync(path.join(root, type.name), { withFileTypes: true })) {
-            if (file.isFile() && file.name.endsWith(".md"))
-                out.push(`ontology/entities/${type.name}/${file.name}`);
-        }
-    }
-    return out.sort();
-}
-/** Company-relative `.md` files outside the entity tree and the rendered brief. */
-function listOtherFiles(company) {
-    const out = [];
-    const walk = (rel) => {
-        for (const entry of fs.readdirSync(path.join(company.dir, rel), { withFileTypes: true })) {
-            if (entry.name.startsWith(".") || entry.name === "node_modules")
-                continue;
-            const child = rel ? `${rel}/${entry.name}` : entry.name;
-            if (entry.isDirectory()) {
-                if (child !== "ontology/entities")
-                    walk(child);
-            }
-            else if (entry.isFile() && entry.name.endsWith(".md") && child !== "company-brief.md") {
-                out.push(child);
-            }
-        }
-    };
-    walk("");
-    return out.sort();
-}
-/**
- * Files outside the entity tree that link to a copy, by markdown link,
- * `[[ontology/entities/...]]` annotation or a front-matter `path:` entry.
- * These files are not the merge's to rewrite, so a copy they name is held.
- */
-function scanOtherLinks(company, copies) {
-    const out = new Map();
-    if (copies.size === 0)
-        return out;
-    const names = [...new Set([...copies].map((copy) => path.posix.basename(copy, ".md")))];
-    const add = (target, rel) => {
-        if (!copies.has(target))
-            return;
-        let set = out.get(target);
-        if (!set)
-            out.set(target, (set = new Set()));
-        set.add(rel);
-    };
-    for (const rel of listOtherFiles(company)) {
-        const content = read(company, rel);
-        if (!names.some((name) => content.includes(name) || content.includes(encodeURI(name))))
-            continue;
-        for (const match of content.matchAll(MD_LINK)) {
-            const target = resolveLink(rel, match[1]);
-            if (target)
-                add(target, rel);
-        }
-        for (const match of content.matchAll(/\[\[(ontology\/entities\/[^\]|\n]+?)(?:\|[^\]\n]*)?\]\]/g)) {
-            add(match[1].endsWith(".md") ? match[1] : `${match[1]}.md`, rel);
-        }
-        for (const match of content.matchAll(/^\s*(?:- )?path:\s*["']?(ontology\/entities\/[^"'\n]+?\.md)["']?\s*$/gm))
-            add(match[1], rel);
-    }
-    return out;
-}
-function scanLinks(company) {
-    const scan = { inbound: new Map(), broken: 0 };
-    for (const rel of listEntityFiles(company)) {
-        const content = fs.readFileSync(path.join(company.dir, rel), "utf8");
-        for (const match of content.matchAll(MD_LINK)) {
-            const target = resolveLink(rel, match[1]);
-            if (!target)
-                continue;
-            if (!fs.existsSync(path.join(company.dir, target)))
-                scan.broken += 1;
-            if (target === rel)
-                continue;
-            let set = scan.inbound.get(target);
-            if (!set)
-                scan.inbound.set(target, (set = new Set()));
-            set.add(rel);
-        }
-    }
-    return scan;
-}
-/** Signal files whose `entity_refs` name a copy, keyed by the copy's path. */
-function scanSignalRefs(company, copies) {
-    const out = new Map();
-    if (copies.size === 0)
-        return out;
-    const byRef = new Map();
-    for (const copy of copies) {
-        const [, , type, file] = copy.split("/");
-        byRef.set(`${type}/${file.slice(0, -3)}`, copy);
-    }
-    for (const rel of listSignalFiles(company.dir)) {
-        for (const ref of readSignal(company.dir, rel)?.refs ?? []) {
-            // Signals write refs both as `type/slug` and as `type/slug.md`.
-            const copy = byRef.get(ref.endsWith(".md") ? ref.slice(0, -3) : ref);
-            if (copy)
-                out.set(copy, [...(out.get(copy) ?? []), rel]);
-        }
-    }
-    return out;
-}
-/** Re-point every link in `content` that resolves to `copy` at `original`. */
-function relink(fromRel, content, copy, original) {
-    return content.replace(MD_LINK, (whole, href) => {
-        if (resolveLink(fromRel, href) !== copy)
-            return whole;
-        const hash = href.indexOf("#");
-        const target = hash === -1 ? href : href.slice(0, hash);
-        const fragment = hash === -1 ? "" : href.slice(hash);
-        const cut = target.lastIndexOf("/");
-        const name = path.posix.basename(original);
-        const encoded = target.slice(cut + 1).includes("%20") ? encodeURI(name) : name;
-        return `](${target.slice(0, cut + 1)}${encoded}${fragment})`;
-    });
-}
-const FRONT_RE = /^---\r?\n([\s\S]*?)\r?\n---(\r?\n|$)/;
-const REL_REF = /^(\s*(?:- )?[A-Za-z_][A-Za-z0-9_]*:\s*)(["']?)(\.\.\/[^"'\n]+?\.md)\2\s*$/;
-const WIKI_LINK = /\[\[(ontology\/entities\/[^\]|\n]+?)(\|[^\]\n]*)?\]\]/g;
-const PATH_LINE = /^(\s*(?:- )?path:\s*)(["']?)(ontology\/entities\/[^"'\n]+?\.md)\2\s*$/;
-function frontLines(content) {
-    const match = FRONT_RE.exec(content);
-    if (!match)
-        return null;
-    return { start: match.index + match[0].indexOf(match[1]), lines: match[1].split(/\r?\n/) };
-}
-/** Put rewritten front-matter lines back; every byte outside them stays. */
-function withFrontLines(content, front, lines, newline) {
-    const originalLength = front.lines.join(newline).length;
-    return `${content.slice(0, front.start)}${lines.join(newline)}${content.slice(front.start + originalLength)}`;
-}
-function fileNewline(content) {
-    return content.includes("\r\n") ? "\r\n" : "\n";
-}
-/** In the front matter only, re-point a `../…md` value that resolves to `copy`. */
-function rewriteRelRefs(fromRel, content, copy, original) {
-    const front = frontLines(content);
-    if (!front)
-        return content;
-    const name = path.posix.basename(original);
-    let changed = false;
-    const lines = front.lines.map((line) => {
-        const match = REL_REF.exec(line);
-        if (!match || resolveLink(fromRel, match[3]) !== copy)
-            return line;
-        const value = match[3];
-        const cut = value.lastIndexOf("/");
-        changed = true;
-        return `${match[1]}${match[2]}${value.slice(0, cut + 1)}${name}${match[2]}`;
-    });
-    if (!changed)
-        return content;
-    return withFrontLines(content, front, lines, fileNewline(content));
-}
-/** Entity files whose front matter points at a copy through a relative ref. */
-function scanRelRefs(company, copies) {
-    const out = new Map();
-    if (copies.size === 0)
-        return out;
-    for (const rel of listEntityFiles(company)) {
-        const front = frontLines(read(company, rel));
-        if (!front)
-            continue;
-        for (const line of front.lines) {
-            const match = REL_REF.exec(line);
-            if (!match)
-                continue;
-            const target = resolveLink(rel, match[3]);
-            if (!target || !copies.has(target))
-                continue;
-            let set = out.get(target);
-            if (!set)
-                out.set(target, (set = new Set()));
-            set.add(rel);
-        }
-    }
-    return out;
-}
-function listItemBounds(lines, pathIndex) {
-    let start = pathIndex;
-    let dashIndent = -1;
-    while (start >= 0) {
-        const dash = /^(\s*)- /.exec(lines[start]);
-        if (dash) {
-            dashIndent = dash[1].length;
-            break;
-        }
-        start -= 1;
-    }
-    if (dashIndent < 0)
-        return null;
-    let keyIndent = -1;
-    for (let i = start + 1; i < lines.length; i += 1) {
-        if (lines[i].trim() === "")
-            continue;
-        const indent = /^(\s*)/.exec(lines[i])[1].length;
-        if (indent <= dashIndent)
-            break;
-        keyIndent = indent;
-        break;
-    }
-    if (keyIndent < 0)
-        keyIndent = dashIndent + 1;
-    let end = start + 1;
-    while (end < lines.length) {
-        const line = lines[end];
-        const dash = /^(\s*)- /.exec(line);
-        if (dash && dash[1].length === dashIndent)
-            break;
-        if (line.trim() !== "" && /^(\s*)/.exec(line)[1].length < keyIndent)
-            break;
-        end += 1;
-    }
-    return { start, end };
-}
-function rewriteWikiLinks(content, copy, original) {
-    WIKI_LINK.lastIndex = 0;
-    return content.replace(WIKI_LINK, (whole, target, label) => {
-        const resolved = target.endsWith(".md") ? target : `${target}.md`;
-        if (resolved !== copy)
-            return whole;
-        const next = target.endsWith(".md") ? original : original.slice(0, -3);
-        return `[[${next}${label ?? ""}]]`;
-    });
-}
-/**
- * Re-point markdown links, wiki-links, annotation `path:` lines and, when both
- * ids are known, the `id:` of that same list item.
- */
-function rewriteOtherFile(fromRel, content, copy, original, copyId, originalId) {
-    const linked = rewriteWikiLinks(relink(fromRel, content, copy, original), copy, original);
-    const newline = fileNewline(content);
-    const lines = linked.split(/\r?\n/);
-    for (let i = 0; i < lines.length; i += 1) {
-        const pathMatch = PATH_LINE.exec(lines[i]);
-        if (!pathMatch || pathMatch[3] !== copy)
-            continue;
-        lines[i] = `${pathMatch[1]}${pathMatch[2]}${original}${pathMatch[2]}`;
-        if (typeof copyId !== "string" || typeof originalId !== "string")
-            continue;
-        const bounds = listItemBounds(lines, i);
-        if (!bounds)
-            continue;
-        for (let j = bounds.start; j < bounds.end; j += 1) {
-            const idMatch = /^(\s*id:\s*)(["']?)([^"'\n]*?)\2(\s*)$/.exec(lines[j]);
-            if (idMatch && idMatch[3] === copyId)
-                lines[j] = `${idMatch[1]}${idMatch[2]}${originalId}${idMatch[2]}${idMatch[4]}`;
-        }
-    }
-    return lines.join(newline);
-}
-/** True when `content` still names `copy` by a link, wiki-link, path or front-matter ref. */
-function referencesCopy(fromRel, content, copy) {
-    MD_LINK.lastIndex = 0;
-    for (const match of content.matchAll(MD_LINK)) {
-        if (resolveLink(fromRel, match[1]) === copy)
-            return true;
-    }
-    WIKI_LINK.lastIndex = 0;
-    for (const match of content.matchAll(WIKI_LINK)) {
-        const target = match[1].endsWith(".md") ? match[1] : `${match[1]}.md`;
-        if (target === copy)
-            return true;
-    }
-    for (const line of content.split(/\r?\n/)) {
-        const pathMatch = PATH_LINE.exec(line);
-        if (pathMatch && pathMatch[3] === copy)
-            return true;
-    }
-    const front = frontLines(content);
-    if (front) {
-        for (const line of front.lines) {
-            const rel = REL_REF.exec(line);
-            if (rel && resolveLink(fromRel, rel[3]) === copy)
-                return true;
-        }
-    }
-    return false;
-}
-/**
- * Signals and sources are written by the server pipeline and the sync
- * client never pushes them, so a rewrite made here would not reach the
- * vault (hq-cloud cloud-authoritative.ts).
- */
-function isServerOwnedRel(rel) {
-    return rel.startsWith("signals/") || rel.startsWith("sources/");
-}
-const REF_KEYS = new Set(["system", "namespace", "objectType", "recordId"]);
-function refKey(ref) {
-    return `${ref.system}:${ref.namespace}:${ref.recordId}`.toLowerCase();
-}
-/** An `external_refs` entry, or null when it has another shape (so it is never rewritten). */
-function readRef(raw) {
-    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
-        return null;
-    const record = raw;
-    if (!Object.keys(record).every((key) => REF_KEYS.has(key)))
-        return null;
-    if (!Object.values(record).every((value) => typeof value === "string" && value.length > 0))
-        return null;
-    if (record.system === undefined || record.namespace === undefined || record.recordId === undefined)
-        return null;
-    return record;
-}
-/** `external_ids` and `web_domains` of a front matter, or "identity_shape". */
-function readIdentity(frontmatter) {
-    let ids = {};
-    if (frontmatter.external_ids !== undefined) {
-        const raw = frontmatter.external_ids;
-        if (raw === null || typeof raw !== "object" || Array.isArray(raw))
-            return "identity_shape";
-        ids = {};
-        for (const [key, value] of Object.entries(raw)) {
-            if (typeof value !== "string")
-                return "identity_shape";
-            ids[key] = value;
-        }
-    }
-    if (frontmatter.web_domains !== undefined) {
-        if (!Array.isArray(frontmatter.web_domains) || !frontmatter.web_domains.every((domain) => typeof domain === "string")) {
-            return "identity_shape";
-        }
-    }
-    const domains = frontmatter.web_domains === undefined ? [] : frontmatter.web_domains;
-    const refs = [];
-    if (frontmatter.external_refs !== undefined) {
-        if (!Array.isArray(frontmatter.external_refs))
-            return "identity_shape";
-        for (const raw of frontmatter.external_refs) {
-            const ref = readRef(raw);
-            if (!ref)
-                return "identity_shape";
-            refs.push(ref);
-        }
-    }
-    return { ids, domains, refs };
-}
-/**
- * The survivor's identity after taking in the copy's. Two different ids for
- * one provider are a conflict unless `resolution` names one of them as
- * primary; the other is then kept in `external_refs`.
- */
-function unionIdentity(original, copy, resolution) {
-    const ids = { ...original.ids };
-    const addIds = [];
-    const conflicts = [];
-    const refs = [...original.refs];
-    const addRefs = [];
-    const seenRefs = new Set(refs.map(refKey));
-    const addRef = (ref) => {
-        const key = refKey(ref);
-        if (seenRefs.has(key))
-            return;
-        seenRefs.add(key);
-        refs.push(ref);
-        addRefs.push(key);
-    };
-    for (const ref of copy.refs)
-        addRef(ref);
-    for (const [key, value] of Object.entries(copy.ids)) {
-        if (!(key in ids)) {
-            ids[key] = value;
-            addIds.push(key);
-        }
-        else if (ids[key] !== value) {
-            const settle = Object.hasOwn(resolution ?? {}, key) ? resolution[key] : undefined;
-            if (!settle || (settle.primary !== ids[key] && settle.primary !== value)) {
-                conflicts.push(key);
-                continue;
-            }
-            const secondary = settle.primary === ids[key] ? value : ids[key];
-            ids[key] = settle.primary;
-            addRef({
-                system: key,
-                namespace: settle.namespace,
-                ...(settle.object_type !== undefined ? { objectType: settle.object_type } : {}),
-                recordId: secondary,
-            });
-        }
-    }
-    const domains = [...original.domains];
-    const addDomains = [];
-    const seen = new Set(original.domains.map((domain) => domain.toLowerCase().trim()));
-    for (const domain of copy.domains) {
-        const key = domain.toLowerCase().trim();
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        domains.push(domain);
-        addDomains.push(domain);
-    }
-    return { ids, domains, refs, addIds, addDomains, addRefs, conflicts };
-}
-function frontMatterId(content) {
-    const id = parseEntityFile(content)?.frontmatter.id;
-    return typeof id === "string" ? id : null;
-}
-/**
- * The original's content with the copy merged in. Never removes anything from
- * the original. `siblings` are all copies of the same original; none of them
- * counts as holding a name.
- */
-function mergeCopy(index, pair, siblings, originalContent, copyContent, now) {
-    const original = parseEntityFile(originalContent);
-    const copy = parseEntityFile(copyContent);
-    if (!original || !copy)
-        return "unparseable";
-    const copyEntity = index.byRel.get(pair.copy);
-    const originalEntity = index.byRel.get(pair.original);
-    if (!copyEntity || !originalEntity)
-        return "not_indexed";
-    const scratch = {
-        ...index,
-        byRel: new Map(index.byRel),
-        canonical: new Map([...index.canonical].map(([k, v]) => [k, new Set(v)])),
-        alias: new Map([...index.alias].map(([k, v]) => [k, new Set(v)])),
-        squashed: new Map([...index.squashed].map(([k, v]) => [k, new Set(v)])),
-    };
-    for (const sibling of siblings)
-        unindex(scratch, sibling);
-    const own = ownNames(scratch, pair.original, []);
-    const names = [copyEntity.canonical_name, ...copyEntity.aliases];
-    const aliases = freshAliases(scratch, pair.type, pair.original, own, names);
-    const moved = new Set(aliases.map((alias) => normalizeEntityName(alias, pair.type)));
-    const dropped = names.filter((name) => {
-        const normalized = normalizeEntityName(name, pair.type);
-        return normalized !== "" && !own.has(normalized) && !moved.has(normalized);
-    });
-    const withRefs = appendBackRefs(originalContent, readBackRefs(copy.body));
-    const lines = missingRelationshipLines(withRefs.content, copyContent, pair);
-    const body = appendRelationshipLines(withRefs.content, lines);
-    const raise = copyEntity.signal_count > originalEntity.signal_count ? copyEntity.signal_count : undefined;
-    const patched = patchEntityFile(body, {
-        addAliases: aliases,
-        signalCount: copyEntity.signal_count,
-        lastUpdated: now.toISOString(),
-        bodyChanged: withRefs.added > 0 || lines.length > 0,
-    });
-    if (!patched.ok)
-        return patched.reason;
-    const have = new Set(splitBody(patched.content)?.body.split(/\r?\n/).map((line) => line.trim()) ?? []);
-    // The copy's `# Name` heading is not content: its name moves to an alias.
-    // The `## Relationships` heading is not content either: its lines count one by one.
-    const heading = `# ${copyEntity.canonical_name}`;
-    const leftover = (splitBody(copyContent)?.body.split(/\r?\n/) ?? [])
-        .map((line) => line.trim())
-        .filter((line) => line !== "" &&
-        line !== heading &&
-        !/^##\s+Relationships$/.test(line) &&
-        !have.has(line) &&
-        !(LINK_ITEM.test(line) && !BACKREF_ITEM.test(line) && isPairSelfLine(line, pair))).length;
-    const keys = [...new Set([...Object.keys(original.frontmatter), ...Object.keys(copy.frontmatter)])].sort();
-    const kept = keys.filter((key) => !OWNED_KEYS.has(key) && !IGNORED_KEYS.has(key) && !isDeepStrictEqual(original.frontmatter[key], copy.frontmatter[key]));
-    return {
-        content: patched.content,
-        changed: patched.changed,
-        aliases,
-        dropped,
-        backrefs: withRefs.added,
-        lines: lines.length,
-        ...(raise !== undefined ? { raise } : {}),
-        kept,
-        leftover,
-    };
-}
-function read(company, rel) {
-    return fs.readFileSync(path.join(company.dir, rel), "utf8");
-}
-/** Links to copies in the company brief (rendered, so reported and not rewritten). */
-function briefLinks(company, copies) {
-    let content;
-    try {
-        content = fs.readFileSync(path.join(company.dir, "company-brief.md"), "utf8");
-    }
-    catch {
-        return [];
-    }
-    const out = new Set();
-    for (const match of content.matchAll(MD_LINK)) {
-        const target = resolveLink("company-brief.md", match[1]);
-        if (target && copies.has(target))
-            out.add(target);
-    }
-    return [...out].sort();
-}
-function plan(company, index, pairs, allPairs, now, rewriteRefs, resolutions = new Map()) {
-    const links = scanLinks(company);
-    const copies = new Set(allPairs.map((pair) => pair.copy));
-    const other = scanOtherLinks(company, copies);
-    if (rewriteRefs) {
-        for (const [copy, rels] of scanRelRefs(company, copies)) {
-            let set = other.get(copy);
-            if (!set)
-                other.set(copy, (set = new Set()));
-            for (const rel of rels)
-                set.add(rel);
-        }
-    }
-    const signalRefs = scanSignalRefs(company, copies);
-    const siblingsOf = new Map();
-    for (const pair of allPairs)
-        siblingsOf.set(pair.original, [...(siblingsOf.get(pair.original) ?? []), pair.copy]);
-    const out = { plans: [], merges: new Map(), finals: new Map(), notReady: new Map() };
-    for (const pair of pairs) {
-        const inbound = [...new Set([...(links.inbound.get(pair.copy) ?? []), ...(other.get(pair.copy) ?? [])])].sort();
-        const refs = (signalRefs.get(pair.copy) ?? []).sort();
-        const siblings = siblingsOf.get(pair.original) ?? [pair.copy];
-        const copyContent = read(company, pair.copy);
-        const onDisk = read(company, pair.original);
-        let merged = mergeCopy(index, pair, siblings, out.finals.get(pair.original) ?? onDisk, copyContent, now);
-        let identity = null;
-        const resolution = resolutions.get(pair.copy);
-        if (rewriteRefs && typeof merged !== "string") {
-            const mergedFront = parseEntityFile(merged.content)?.frontmatter;
-            const copyFront = parseEntityFile(copyContent)?.frontmatter;
-            const mergedIdentity = mergedFront ? readIdentity(mergedFront) : "identity_shape";
-            const copyIdentity = copyFront ? readIdentity(copyFront) : "identity_shape";
-            if (!mergedFront || !copyFront || mergedIdentity === "identity_shape" || copyIdentity === "identity_shape") {
-                merged = "identity_shape";
-            }
-            else {
-                const union = unionIdentity(mergedIdentity, copyIdentity, resolution);
-                if (union.conflicts.length > 0) {
-                    identity = union;
-                }
-                else {
-                    const ids = setIdentityKeys(merged.content, {
-                        externalIds: union.ids,
-                        webDomains: union.domains,
-                        ...(union.addRefs.length > 0 ? { externalRefs: union.refs } : {}),
-                        lastUpdated: now.toISOString(),
-                    });
-                    if (!ids.ok) {
-                        merged = ids.reason;
-                    }
-                    else {
-                        merged = { ...merged, content: ids.content, changed: merged.changed || ids.changed };
-                        identity = union;
-                    }
-                }
-            }
-        }
-        const entry = {
-            ...pair,
-            add_aliases: typeof merged === "string" ? [] : merged.aliases,
-            dropped_aliases: typeof merged === "string" ? [] : merged.dropped,
-            add_backrefs: typeof merged === "string" ? 0 : merged.backrefs,
-            add_relationship_lines: typeof merged === "string" ? 0 : merged.lines,
-            ...(typeof merged !== "string" && merged.raise !== undefined ? { raise_signal_count: merged.raise } : {}),
-            kept_original_keys: typeof merged === "string" ? [] : merged.kept,
-            inbound_links: inbound,
-            signal_refs: refs,
-            unmerged_body_lines: typeof merged === "string" ? 0 : merged.leftover,
-        };
-        if (rewriteRefs && identity && identity.conflicts.length === 0 && typeof merged !== "string") {
-            entry.add_external_ids = identity.addIds;
-            entry.add_web_domains = identity.addDomains;
-            entry.add_external_refs = identity.addRefs;
-        }
-        const unwritable = rewriteRefs
-            ? inbound.filter((rel) => copies.has(rel))
-            : inbound.filter((rel) => !rel.startsWith("ontology/entities/") || !isWritableEntityType(rel.split("/")[2]) || copies.has(rel));
-        const serverOwned = rewriteRefs ? [...refs, ...inbound.filter(isServerOwnedRel)] : [];
-        if (typeof merged === "string") {
-            entry.held = "merge_invalid";
-            entry.detail = merged;
-        }
-        else if (identity && identity.conflicts.length > 0) {
-            entry.held = "external_id_conflict";
-            entry.detail = identity.conflicts.join(", ");
-        }
-        else if (serverOwned.length > 0) {
-            entry.held = "server_owned_refs";
-            entry.detail = [...new Set(serverOwned)].sort().join(", ");
-        }
-        else if (!rewriteRefs && refs.length > 0) {
-            entry.held = "signal_refs";
-        }
-        else if (unwritable.length > 0) {
-            entry.held = "linked_from_unwritable";
-            entry.detail = unwritable.join(", ");
-        }
-        else {
-            out.merges.set(pair.copy, merged);
-            out.finals.set(pair.original, merged.content);
-            // Deletion is judged against the original as it is on disk now.
-            const current = mergeCopy(index, pair, siblings, onDisk, copyContent, now);
-            let reason;
-            if (!rewriteRefs) {
-                reason =
-                    typeof current === "string"
-                        ? "merge_invalid"
-                        : current.changed
-                            ? "not_merged"
-                            : current.leftover > 0
-                                ? "unmerged_body"
-                                : inbound.length > 0
-                                    ? "linked"
-                                    : null;
-            }
-            else if (typeof current === "string") {
-                reason = "merge_invalid";
-            }
-            else {
-                const diskFront = parseEntityFile(onDisk)?.frontmatter;
-                const copyFront = parseEntityFile(copyContent)?.frontmatter;
-                const diskIdentity = diskFront ? readIdentity(diskFront) : "identity_shape";
-                const copyIdentity = copyFront ? readIdentity(copyFront) : "identity_shape";
-                if (!diskFront || !copyFront || diskIdentity === "identity_shape" || copyIdentity === "identity_shape") {
-                    reason = "merge_invalid";
-                }
-                else {
-                    const union = unionIdentity(diskIdentity, copyIdentity, resolution);
-                    const patched = setIdentityKeys(current.content, {
-                        externalIds: union.ids,
-                        webDomains: union.domains,
-                        ...(union.addRefs.length > 0 ? { externalRefs: union.refs } : {}),
-                        lastUpdated: now.toISOString(),
-                    });
-                    reason = union.conflicts.length > 0
-                        ? "external_id_conflict"
-                        : !patched.ok
-                            ? "merge_invalid"
-                            : current.changed || patched.changed
-                                ? "not_merged"
-                                : current.leftover > 0
-                                    ? "unmerged_body"
-                                    : inbound.length > 0
-                                        ? "linked"
-                                        : refs.length > 0
-                                            ? "signal_refs"
-                                            : null;
-                }
-            }
-            if (reason)
-                out.notReady.set(pair.copy, reason);
-        }
-        out.plans.push(entry);
-    }
-    return out;
-}
-function writeEntity(hqRoot, company, rel, content, now) {
-    // Outbox first: sync pushes an entity file only when its bytes match.
-    const write = { rel, content };
-    recordOutbox(hqRoot, company, [write], now);
-    safeWriteFile(hqRoot, [entitiesRoot(company)], path.join(company.dir, rel), content);
-}
-/**
- * Plan, merge or delete numbered copies for one company. The dry run writes
- * nothing; merge writes entity files only; delete removes vault keys and
- * local copy files only.
- */
-export async function mergeCopies(options) {
-    const { hqRoot, company, mode, now } = options;
-    const index = buildEntityIndex(company.dir);
-    const pairKind = options.pairKind ?? "numbered";
-    if (pairKind === "listed" && !options.only)
-        throw new Error("merge-copies: listed pairs need an only list");
-    const found = pairKind === "listed"
-        ? findListedPairs(index, options.only)
-        : pairKind === "variants"
-            ? findVariantPairs(index)
-            : findCopyPairs(index);
-    const listed = options.only
-        ? found.pairs.filter((pair) => options.only.some((entry) => entry.copy === pair.copy && entry.original === pair.original))
-        : found.pairs;
-    const pairs = options.limit !== undefined ? listed.slice(0, Math.max(0, options.limit)) : listed;
-    const before = scanLinks(company).broken;
-    const rewriteRefs = options.rewriteRefs === true;
-    const resolutions = new Map();
-    for (const entry of options.only ?? []) {
-        if (entry.resolve_external_ids)
-            resolutions.set(entry.copy, entry.resolve_external_ids);
-    }
-    const { plans, merges, finals, notReady } = plan(company, index, pairs, found.pairs, now, rewriteRefs, resolutions);
-    const report = {
-        company: company.slug,
-        mode,
-        pair_kind: pairKind,
-        duplicate_groups_before: findDuplicateGroups(index).length,
-        duplicate_groups_after: 0,
-        copies_found: found.pairs.length,
-        plans,
-        skipped: options.only
-            ? [
-                ...found.skipped,
-                ...found.pairs
-                    .filter((pair) => !listed.includes(pair))
-                    .map((pair) => ({ copy: pair.copy, reason: "not_listed" })),
-            ]
-            : found.skipped,
-        ...(options.only
-            ? {
-                only_unmatched: options.only.filter((entry) => !found.pairs.some((pair) => pair.copy === entry.copy && pair.original === entry.original)),
-            }
-            : {}),
-        merged: [],
-        relinked: [],
-        ...(rewriteRefs ? { rewritten: [] } : {}),
-        deleted: [],
-        vault_already_absent: [],
-        not_ready: [],
-        errors: [],
-        broken_links_before: before,
-        broken_links_after: before,
-        brief_links_to_copies: briefLinks(company, new Set(pairs.map((pair) => pair.copy))),
-    };
-    if (mode === "merge") {
-        // Originals first, once each with every copy merged in; then links, read
-        // back from disk so a relinked original keeps its merge.
-        for (const [original, content] of finals) {
-            try {
-                if (content === read(company, original))
-                    continue;
-                writeEntity(hqRoot, company, original, content, now);
-                report.merged.push(original);
-            }
-            catch (error) {
-                report.errors.push({ path: original, error: error.name });
-            }
-        }
-        for (const entry of plans) {
-            if (!merges.has(entry.copy))
-                continue;
-            const copyId = rewriteRefs ? frontMatterId(read(company, entry.copy)) : null;
-            const originalId = rewriteRefs ? frontMatterId(read(company, entry.original)) : null;
-            for (const rel of entry.inbound_links) {
-                try {
-                    const content = read(company, rel);
-                    if (!rewriteRefs) {
-                        const next = relink(rel, content, entry.copy, entry.original);
-                        if (next === content)
-                            continue;
-                        writeEntity(hqRoot, company, rel, next, now);
-                        if (!report.relinked.includes(rel))
-                            report.relinked.push(rel);
-                        continue;
-                    }
-                    const next = rel.startsWith("ontology/entities/")
-                        ? rewriteRelRefs(rel, relink(rel, content, entry.copy, entry.original), entry.copy, entry.original)
-                        : rewriteOtherFile(rel, content, entry.copy, entry.original, copyId, originalId);
-                    if (next === content)
-                        continue;
-                    if (referencesCopy(rel, next, entry.copy)) {
-                        report.errors.push({ path: rel, error: "link_not_rewritten" });
-                        continue;
-                    }
-                    if (rel.startsWith("ontology/entities/")) {
-                        writeEntity(hqRoot, company, rel, next, now);
-                        if (!report.relinked.includes(rel))
-                            report.relinked.push(rel);
-                    }
-                    else {
-                        safeWriteFile(hqRoot, [company.dir], path.join(company.dir, rel), next);
-                        if (!report.rewritten.includes(rel))
-                            report.rewritten.push(rel);
-                    }
-                }
-                catch (error) {
-                    report.errors.push({ path: rel, error: error.name });
-                }
-            }
-        }
-    }
-    if (mode === "delete") {
-        if (!options.deleteVaultKey)
-            throw new Error("merge-copies: delete needs a vault client");
-        for (const entry of plans) {
-            const reason = entry.held ?? notReady.get(entry.copy) ?? null;
-            if (reason) {
-                report.not_ready.push({ copy: entry.copy, reason });
-                continue;
-            }
-            try {
-                const deleted = await options.deleteVaultKey(entry.copy);
-                // 0 means the exact key is already gone (a run that stopped before the
-                // local removal, or a copy that never synced): finish the local side.
-                if (deleted !== 1 && deleted !== 0) {
-                    report.errors.push({ path: entry.copy, error: `vault_deleted_${deleted}` });
-                    continue;
-                }
-                fs.rmSync(path.join(company.dir, entry.copy), { force: true });
-                report.deleted.push(entry.copy);
-                if (deleted === 0)
-                    report.vault_already_absent.push(entry.copy);
-            }
-            catch (error) {
-                report.errors.push({ path: entry.copy, error: error.message || error.name });
-            }
-        }
-    }
-    const after = buildEntityIndex(company.dir);
-    report.duplicate_groups_after = findDuplicateGroups(after).length;
-    report.broken_links_after = scanLinks(company).broken;
-    return report;
-}
-//# sourceMappingURL=merge-copies.js.map