@indigoai-us/hq-cli 5.291.0 → 5.292.0

package/dist/commands/core-ontology.d.ts

@@ -9,7 +9,8 @@
  */
 import { Command } from "commander";
 import { type FlagReader } from "../lib/checkpoint-ontology/plan.js";
-import { type DeleteVaultKey, type ListedPair } from "../lib/checkpoint-ontology/merge-copies.js";
+import { type AliasDrop } from "../lib/checkpoint-ontology/drop-aliases.js";
+import { type DeleteVaultKey, type ListedPair, type MergeCopiesReport } from "../lib/checkpoint-ontology/merge-copies.js";
 export declare const ONTOLOGY_PAYLOAD_FILE = "payload.json";
 /** The hq-flags read, scoped to the payload company. */
 export declare const registryFlagReader: FlagReader;
@@ -31,12 +32,15 @@ export interface MergeCopiesCommandOptions {
     apply?: boolean;
     delete?: boolean;
     variants?: boolean;
+    /** Merge exactly the `--only` pairs, whatever their names (flag merge-listed-pairs). */
+    listed?: boolean;
     limit?: number;
     only?: string;
     /** Also re-point refs and links held today (flag merge-rewrite-refs). */
     rewriteRefs?: boolean;
     json?: boolean;
 }
+export declare function mergeCopiesSummary(report: MergeCopiesReport): string;
 /** Reads a `--only` file: a JSON array of `{ copy, original }` company-relative paths. */
 export declare function readListedPairs(file: string): ListedPair[];
 /**
@@ -47,10 +51,24 @@ export declare function readListedPairs(file: string): ListedPair[];
  * With `--variants`, merges two-file duplicate groups whose names differ only
  * in case, spacing or punctuation instead, gated by
  * `checkpoint.ontology.merge-variants`. `--rewrite-refs` (flag
- * `checkpoint.ontology.merge-rewrite-refs`) also re-points signal refs,
- * invoice and bill links, source and knowledge links, and carries external
- * ids and web domains.
+ * `checkpoint.ontology.merge-rewrite-refs`) also re-points invoice and
+ * knowledge links to the survivor and carries external ids and web domains;
+ * pairs named by signals or sources stay held. `--listed` (flag
+ * `checkpoint.ontology.merge-listed-pairs`) merges exactly the `--only` pairs,
+ * which a person reviewed, instead of the pairs a finder produces.
  */
 export declare function runOntologyMergeCopies(hqRoot: string, slug: string | undefined, options: MergeCopiesCommandOptions, deps?: OntologyCommandDeps): Promise<string>;
+/** Reads a `drop-aliases --only` file: a JSON array of `{ entity, alias }`. */
+export declare function readAliasDrops(file: string): AliasDrop[];
+/**
+ * `hq core ontology drop-aliases`: remove the reviewed `{ entity, alias }`
+ * pairs in `--only` from entity files (`--apply`); without it only reports.
+ * Gated by `checkpoint.ontology.drop-aliases` and `checkpoint.ontology.multi-writer`.
+ */
+export declare function runOntologyDropAliases(hqRoot: string, slug: string | undefined, options: {
+    only?: string;
+    apply?: boolean;
+    json?: boolean;
+}, deps?: OntologyCommandDeps): Promise<string>;
 export declare function registerCoreOntologyCommand(core: Command): void;
 //# sourceMappingURL=core-ontology.d.ts.map

package/dist/commands/core-ontology.js

@@ -17,7 +17,8 @@ import { applyOntologyRun, ApplyError } from "../lib/checkpoint-ontology/apply.j
 import { resolveOntologyCompany, WriteBoundsError } from "../lib/checkpoint-ontology/company.js";
 import { findDuplicateGroups, summarizeMergeBack, } from "../lib/checkpoint-ontology/multi-writer.js";
 import { buildEntityIndex } from "../lib/checkpoint-ontology/tree.js";
-import { MERGE_COPIES_FLAG, MERGE_REWRITE_REFS_FLAG, MERGE_VARIANTS_FLAG, mergeCopies, } from "../lib/checkpoint-ontology/merge-copies.js";
+import { DROP_ALIASES_FLAG, dropAliases } from "../lib/checkpoint-ontology/drop-aliases.js";
+import { MERGE_COPIES_FLAG, MERGE_LISTED_PAIRS_FLAG, MERGE_REWRITE_REFS_FLAG, MERGE_VARIANTS_FLAG, mergeCopies, } from "../lib/checkpoint-ontology/merge-copies.js";
 import { callDeleteEndpoint } from "./files.js";
 import { resolveVaultCredential } from "../utils/resolve-vault-credential.js";
 import { registerCoreOntologyNativeCommands } from "./core-ontology-native.js";
@@ -142,7 +143,7 @@ async function companyVaultDeleter(companyUid) {
         return (await callDeleteEndpoint({ token, companyUid, prefix: key, dryRun: false })).deleted;
     };
 }
-function mergeCopiesSummary(report) {
+export function mergeCopiesSummary(report) {
     const held = report.plans.filter((plan) => plan.held).length;
     const lines = [
         `ontology merge-copies (${report.mode.replace("_", " ")}) in ${report.company} (${report.pair_kind}): ${report.plans.length} of ${report.copies_found} copies, ${held} held, ${report.skipped.length} skipped`,
@@ -150,7 +151,7 @@ function mergeCopiesSummary(report) {
         `  duplicate groups ${report.duplicate_groups_before} -> ${report.duplicate_groups_after}; broken entity links ${report.broken_links_before} -> ${report.broken_links_after}`,
     ];
     for (const plan of report.plans.filter((entry) => entry.held)) {
-        lines.push(`  held ${plan.copy}: ${plan.held}${plan.held === "external_id_conflict" ? ` (${plan.detail})` : ""}`);
+        lines.push(`  held ${plan.copy}: ${plan.held}${plan.held === "external_id_conflict" || plan.held === "server_owned_refs" ? ` (${plan.detail})` : ""}`);
     }
     for (const error of report.errors)
         lines.push(`  error ${error.path}: ${error.error}`);
@@ -216,9 +217,11 @@ function readResolution(copy, raw) {
  * With `--variants`, merges two-file duplicate groups whose names differ only
  * in case, spacing or punctuation instead, gated by
  * `checkpoint.ontology.merge-variants`. `--rewrite-refs` (flag
- * `checkpoint.ontology.merge-rewrite-refs`) also re-points signal refs,
- * invoice and bill links, source and knowledge links, and carries external
- * ids and web domains.
+ * `checkpoint.ontology.merge-rewrite-refs`) also re-points invoice and
+ * knowledge links to the survivor and carries external ids and web domains;
+ * pairs named by signals or sources stay held. `--listed` (flag
+ * `checkpoint.ontology.merge-listed-pairs`) merges exactly the `--only` pairs,
+ * which a person reviewed, instead of the pairs a finder produces.
  */
 export async function runOntologyMergeCopies(hqRoot, slug, options, deps = {}) {
     if (options.apply && options.delete) {
@@ -227,13 +230,20 @@ export async function runOntologyMergeCopies(hqRoot, slug, options, deps = {}) {
     if (options.limit !== undefined && (!Number.isInteger(options.limit) || options.limit < 1)) {
         throw new OntologyUsageError("ontology: --limit must be a positive whole number");
     }
+    if (options.listed && options.variants) {
+        throw new OntologyUsageError("ontology: use either --listed or --variants");
+    }
+    if (options.listed && options.only === undefined) {
+        throw new OntologyUsageError("ontology: --listed needs --only <file>");
+    }
     const only = options.only !== undefined ? readListedPairs(options.only) : undefined;
     const resolution = resolveOntologyCompany(hqRoot, slug);
     if (!resolution.ok)
         throw new OntologyUsageError(`ontology: company rejected: ${resolution.reason}`);
     const company = resolution.company;
     const readFlag = deps.readFlag ?? registryFlagReader;
-    for (const flag of [options.variants ? MERGE_VARIANTS_FLAG : MERGE_COPIES_FLAG, MULTI_WRITER_FLAG, ...(options.rewriteRefs ? [MERGE_REWRITE_REFS_FLAG] : [])]) {
+    const kindFlag = options.listed ? MERGE_LISTED_PAIRS_FLAG : options.variants ? MERGE_VARIANTS_FLAG : MERGE_COPIES_FLAG;
+    for (const flag of [kindFlag, MULTI_WRITER_FLAG, ...(options.rewriteRefs ? [MERGE_REWRITE_REFS_FLAG] : [])]) {
         if (!(await readFlag(flag, company))) {
             return options.json ? JSON.stringify({ company: company.slug, skipped: `${flag} off` }) : `ontology merge-copies: skipped (${flag} is off)`;
         }
@@ -251,6 +261,7 @@ export async function runOntologyMergeCopies(hqRoot, slug, options, deps = {}) {
         mode,
         now: deps.now?.() ?? new Date(),
         ...(options.variants ? { pairKind: "variants" } : {}),
+        ...(options.listed ? { pairKind: "listed" } : {}),
         ...(options.limit !== undefined ? { limit: options.limit } : {}),
         ...(only ? { only } : {}),
         ...(options.rewriteRefs ? { rewriteRefs: true } : {}),
@@ -258,6 +269,59 @@ export async function runOntologyMergeCopies(hqRoot, slug, options, deps = {}) {
     });
     return options.json ? JSON.stringify(report, null, 2) : mergeCopiesSummary(report);
 }
+/** Reads a `drop-aliases --only` file: a JSON array of `{ entity, alias }`. */
+export function readAliasDrops(file) {
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch (error) {
+        throw new OntologyUsageError(`ontology: --only file ${file} is not readable JSON: ${error.message}`);
+    }
+    const usage = "ontology: --only must be a non-empty JSON array of { entity, alias } strings";
+    if (!Array.isArray(parsed) || parsed.length === 0)
+        throw new OntologyUsageError(usage);
+    return parsed.map((item) => {
+        const record = item;
+        if (!record || typeof record.entity !== "string" || typeof record.alias !== "string" || record.alias === "") {
+            throw new OntologyUsageError(usage);
+        }
+        return { entity: record.entity, alias: record.alias };
+    });
+}
+/**
+ * `hq core ontology drop-aliases`: remove the reviewed `{ entity, alias }`
+ * pairs in `--only` from entity files (`--apply`); without it only reports.
+ * Gated by `checkpoint.ontology.drop-aliases` and `checkpoint.ontology.multi-writer`.
+ */
+export async function runOntologyDropAliases(hqRoot, slug, options, deps = {}) {
+    if (options.only === undefined)
+        throw new OntologyUsageError("ontology: drop-aliases needs --only <file>");
+    const drops = readAliasDrops(options.only);
+    const resolution = resolveOntologyCompany(hqRoot, slug);
+    if (!resolution.ok)
+        throw new OntologyUsageError(`ontology: company rejected: ${resolution.reason}`);
+    const company = resolution.company;
+    const readFlag = deps.readFlag ?? registryFlagReader;
+    for (const flag of [DROP_ALIASES_FLAG, MULTI_WRITER_FLAG]) {
+        if (!(await readFlag(flag, company))) {
+            return options.json ? JSON.stringify({ company: company.slug, skipped: `${flag} off` }) : `ontology drop-aliases: skipped (${flag} is off)`;
+        }
+    }
+    const report = dropAliases({ hqRoot, company, mode: options.apply ? "apply" : "dry_run", drops, now: deps.now?.() ?? new Date() });
+    if (options.json)
+        return JSON.stringify(report, null, 2);
+    const planned = Object.values(report.planned).reduce((sum, list) => sum + list.length, 0);
+    const lines = [
+        `ontology drop-aliases (${report.mode.replace("_", " ")}) in ${report.company}: ${planned} alias(es) on ${Object.keys(report.planned).length} entities, written ${report.written.length}, skipped ${report.skipped.length}, errors ${report.errors.length}`,
+        `  duplicate groups ${report.duplicate_groups_before} -> ${report.duplicate_groups_after}`,
+    ];
+    for (const skip of report.skipped)
+        lines.push(`  skipped ${skip.entity} "${skip.alias}": ${skip.reason}${skip.detail ? ` (${skip.detail})` : ""}`);
+    for (const error of report.errors)
+        lines.push(`  error ${error.path}: ${error.error}`);
+    return lines.join("\n");
+}
 function fail(error) {
     if (error instanceof OntologyUsageError || error instanceof ApplyError || error instanceof WriteBoundsError) {
         process.stderr.write(`${error.message}\n`);
@@ -306,9 +370,10 @@ export function registerCoreOntologyCommand(core) {
         .option("--apply", "merge each copy into its original and re-point links (writes entity files)")
         .option("--delete", "delete fully merged copies from the vault by exact key (after sync pushed the merge)")
         .option("--variants", "merge two-file duplicate groups whose names differ only in case, spacing or punctuation (checkpoint.ontology.merge-variants)")
+        .option("--listed", "merge exactly the pairs in the --only file, whatever their names (checkpoint.ontology.merge-listed-pairs)")
         .option("--limit <n>", "handle at most this many copies", (value) => Number(value))
         .option("--only <file>", "handle only the copy -> original pairs listed in this JSON file")
-        .option("--rewrite-refs", "also re-point signal refs, invoice, source and knowledge links to the survivor and carry external ids and web domains (checkpoint.ontology.merge-rewrite-refs)")
+        .option("--rewrite-refs", "also re-point invoice and knowledge links to the survivor and carry external ids and web domains; pairs named by signals or sources stay held (checkpoint.ontology.merge-rewrite-refs)")
         .option("--json", "print JSON")
         .option("--hq-root <path>", "HQ installation to operate on")
         .action(async (options) => {
@@ -320,6 +385,23 @@ export function registerCoreOntologyCommand(core) {
         }
     });
     describeCoreCommand(mergeCopies, { execution: "native", root: "live" });
+    const dropAliasesCommand = ontology
+        .command("drop-aliases")
+        .description("Remove reviewed wrong aliases from entity files (dry run by default)")
+        .requiredOption("--company <slug>", "company to change")
+        .option("--only <file>", "JSON array of { entity, alias } to remove; entity is a company-relative path")
+        .option("--apply", "write the entity files")
+        .option("--json", "print JSON")
+        .option("--hq-root <path>", "HQ installation to operate on")
+        .action(async (options) => {
+        try {
+            process.stdout.write(`${await runOntologyDropAliases(rootFor(options), options.company, options)}\n`);
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+    describeCoreCommand(dropAliasesCommand, { execution: "native", root: "live" });
     const apply = ontology
         .command("apply")
         .description("Validate the run's entity candidates and write them to the payload company")

package/dist/commands/core.js

@@ -214,6 +214,11 @@ export const SCAFFOLD_COMMANDS = [
 export const SCAFFOLD_ONLY_ASSETS = [
     { asset: "core/scripts/jobs-schedule-parse.sh", root: "live", summary: "Rollback companion for native jobs schedule-parse" },
     { asset: "core/scripts/jobs-validate.sh", root: "live", summary: "Rollback companion for native jobs validate" },
+    { asset: "core/scripts/outpost-jobs-reconcile.sh", root: "live", summary: "Rollback companion for native jobs reconcile" },
+    { asset: "core/scripts/hq-job-probe.sh", root: "live", summary: "Scheduled jobs readiness probe used by the reconcile rollback path" },
+    { asset: "core/scripts/hq-job-run.sh", root: "live", summary: "Scheduled jobs runner used by generated systemd units" },
+    { asset: "core/scripts/hq-job-notify.sh", root: "live", summary: "Scheduled jobs failure notification helper" },
+    { asset: "core/scripts/hq-job-remediate.sh", root: "live", summary: "Scheduled jobs bounded remediation helper" },
     // Shared shell libs sourced by the two relocated scripts (and hooks). Never
     // dispatched on their own (so no `hq core` command), but they MUST ship in the
     // tarball, or the bundled hq-session / checkpoint-stop-gate die at `source`
@@ -235,6 +240,11 @@ export const SCAFFOLD_ONLY_ASSETS = [
     { asset: "core/scripts/hq-delegate-repo.sh", root: "live", summary: "Rollback shell for native delegate repo" },
     { asset: "core/scripts/hq-delegate-secrets.sh", root: "live", summary: "Rollback shell for native delegate secrets" },
     { asset: "core/scripts/hq-delegate-transfer.sh", root: "live", summary: "Rollback shell for native delegate transfer" },
+    { asset: "core/scripts/hq-delegate-bundle.sh", root: "live", summary: "Rollback shell for native delegate bundle" },
+    { asset: "core/scripts/hq-delegate-grant.sh", root: "live", summary: "Rollback shell for native delegate grant" },
+    { asset: "core/scripts/hq-delegate-publish.sh", root: "live", summary: "Rollback shell for native delegate publish" },
+    { asset: "core/scripts/hq-delegate-send.sh", root: "live", summary: "Rollback shell for native delegate send" },
+    { asset: "core/scripts/hq-delegate-verify.sh", root: "live", summary: "Rollback shell for native delegate verify" },
     { asset: "core/scripts/lib/secret-patterns.sh", root: "live", summary: "Secret-pattern library sourced by the delegate rollback shells" },
     // Retained rollback companions for the gated native ontology commands. These
     // are loose HQ-tree assets, but `hq core ontology` dispatches natively.

package/dist/lib/checkpoint-ontology/drop-aliases.d.ts

@@ -0,0 +1,41 @@
+/**
+ * `hq core ontology drop-aliases`: remove reviewed wrong aliases from entity
+ * files (CO-74). An alias that names a different entity joins two unrelated
+ * entities into one duplicate group; a person lists each `{ entity, alias }`
+ * to remove, and nothing else changes. The dry run writes nothing; `apply`
+ * writes the entity files through the multi-writer outbox so sync pushes them.
+ */
+import { type OntologyCompany } from "./company.js";
+export declare const DROP_ALIASES_FLAG = "checkpoint.ontology.drop-aliases";
+/** One reviewed removal: `entity` is a company-relative entity path. */
+export interface AliasDrop {
+    entity: string;
+    alias: string;
+}
+export type AliasDropSkipReason = "no_entity" | "type_not_writable" | "alias_absent" | "patch_failed";
+export interface AliasDropReport {
+    company: string;
+    mode: "dry_run" | "apply";
+    duplicate_groups_before: number;
+    duplicate_groups_after: number;
+    /** Entity -> aliases removed (dry run: would be removed). */
+    planned: Record<string, string[]>;
+    written: string[];
+    skipped: Array<AliasDrop & {
+        reason: AliasDropSkipReason;
+        detail?: string;
+    }>;
+    errors: Array<{
+        path: string;
+        error: string;
+    }>;
+}
+export interface DropAliasesOptions {
+    hqRoot: string;
+    company: OntologyCompany;
+    mode: "dry_run" | "apply";
+    drops: AliasDrop[];
+    now: Date;
+}
+export declare function dropAliases(options: DropAliasesOptions): AliasDropReport;
+//# sourceMappingURL=drop-aliases.d.ts.map

package/dist/lib/checkpoint-ontology/drop-aliases.js

@@ -0,0 +1,76 @@
+/**
+ * `hq core ontology drop-aliases`: remove reviewed wrong aliases from entity
+ * files (CO-74). An alias that names a different entity joins two unrelated
+ * entities into one duplicate group; a person lists each `{ entity, alias }`
+ * to remove, and nothing else changes. The dry run writes nothing; `apply`
+ * writes the entity files through the multi-writer outbox so sync pushes them.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { entitiesRoot, safeWriteFile } from "./company.js";
+import { patchEntityFile } from "./entity-file.js";
+import { isWritableEntityType } from "./identity.js";
+import { findDuplicateGroups, recordOutbox } from "./multi-writer.js";
+import { buildEntityIndex } from "./tree.js";
+export const DROP_ALIASES_FLAG = "checkpoint.ontology.drop-aliases";
+export function dropAliases(options) {
+    const { hqRoot, company, mode, drops, now } = options;
+    const index = buildEntityIndex(company.dir);
+    const report = {
+        company: company.slug,
+        mode,
+        duplicate_groups_before: findDuplicateGroups(index).length,
+        duplicate_groups_after: 0,
+        planned: {},
+        written: [],
+        skipped: [],
+        errors: [],
+    };
+    const byEntity = new Map();
+    for (const drop of drops) {
+        const entity = index.byRel.get(drop.entity);
+        if (!entity) {
+            report.skipped.push({ ...drop, reason: "no_entity" });
+        }
+        else if (!isWritableEntityType(entity.type)) {
+            report.skipped.push({ ...drop, reason: "type_not_writable" });
+        }
+        else if (!entity.aliases.includes(drop.alias)) {
+            report.skipped.push({ ...drop, reason: "alias_absent" });
+        }
+        else {
+            byEntity.set(drop.entity, [...(byEntity.get(drop.entity) ?? []), drop]);
+        }
+    }
+    const writes = new Map();
+    for (const [rel, list] of [...byEntity].sort(([a], [b]) => a.localeCompare(b))) {
+        const content = fs.readFileSync(path.join(company.dir, rel), "utf8");
+        const patched = patchEntityFile(content, { removeAliases: list.map((drop) => drop.alias), lastUpdated: now.toISOString() });
+        if (!patched.ok) {
+            for (const drop of list)
+                report.skipped.push({ ...drop, reason: "patch_failed", detail: patched.reason });
+            continue;
+        }
+        report.planned[rel] = [...new Set(list.map((drop) => drop.alias))];
+        writes.set(rel, patched.content);
+    }
+    if (mode === "apply") {
+        for (const [rel, content] of writes) {
+            try {
+                // Outbox first: sync pushes an entity file only when its bytes match.
+                recordOutbox(hqRoot, company, [{ rel, content }], now);
+                safeWriteFile(hqRoot, [entitiesRoot(company)], path.join(company.dir, rel), content);
+                report.written.push(rel);
+            }
+            catch (error) {
+                report.errors.push({ path: rel, error: error.name });
+            }
+        }
+        report.duplicate_groups_after = findDuplicateGroups(buildEntityIndex(company.dir)).length;
+    }
+    else {
+        report.duplicate_groups_after = report.duplicate_groups_before;
+    }
+    return report;
+}
+//# sourceMappingURL=drop-aliases.js.map

package/dist/lib/checkpoint-ontology/entity-file.d.ts

@@ -47,6 +47,8 @@ export declare function renderNewEntity(entity: NewEntity): string;
 export declare const OWNED_KEYS: ReadonlySet<string>;
 export interface EntityPatch {
     addAliases?: string[];
+    /** Exact alias strings to remove (reviewed wrong aliases). Applied before `addAliases`. */
+    removeAliases?: string[];
     signalCount?: number;
     lastUpdated: string;
     /** The caller changed the body, so `last_updated` moves even with no key change. */
@@ -61,9 +63,10 @@ export type PatchResult = {
     reason: string;
 };
 /**
- * Patch an existing, valid entity file. Aliases are only appended, and
- * `signal_count` never goes down. When nothing but `last_updated` would
- * change, the file is returned unchanged so a rerun writes nothing.
+ * Patch an existing, valid entity file. Aliases are appended, and removed
+ * only when `removeAliases` names them exactly; `signal_count` never goes
+ * down. When nothing but `last_updated` would change, the file is returned
+ * unchanged so a rerun writes nothing.
  */
 export declare function patchEntityFile(content: string, patch: EntityPatch): PatchResult;
 /** A namespaced record in a source system, as the cloud schema's `external_refs` holds it. */

package/dist/lib/checkpoint-ontology/entity-file.js

@@ -144,9 +144,10 @@ function appendAliases(lines, all, added) {
     return [...lines.slice(0, end), ...added.map((alias) => `${indent}- ${quote(alias)}`), ...lines.slice(end)];
 }
 /**
- * Patch an existing, valid entity file. Aliases are only appended, and
- * `signal_count` never goes down. When nothing but `last_updated` would
- * change, the file is returned unchanged so a rerun writes nothing.
+ * Patch an existing, valid entity file. Aliases are appended, and removed
+ * only when `removeAliases` names them exactly; `signal_count` never goes
+ * down. When nothing but `last_updated` would change, the file is returned
+ * unchanged so a rerun writes nothing.
  */
 export function patchEntityFile(content, patch) {
     const match = FRONTMATTER_RE.exec(content);
@@ -156,19 +157,24 @@ export function patchEntityFile(content, patch) {
     const before = validateEntityFrontmatter(parsed.frontmatter);
     if (typeof before === "string")
         return { ok: false, reason: `invalid_existing:${before}` };
-    const aliases = [...before.aliases];
+    const remove = new Set(patch.removeAliases ?? []);
+    const kept = before.aliases.filter((alias) => !remove.has(alias));
+    const aliases = [...kept];
     for (const alias of patch.addAliases ?? []) {
         if (!aliases.includes(alias))
             aliases.push(alias);
     }
     const signalCount = Math.max(before.signal_count, patch.signalCount ?? 0);
-    const aliasesChanged = aliases.length !== before.aliases.length;
+    const removed = kept.length !== before.aliases.length;
+    const aliasesChanged = removed || aliases.length !== before.aliases.length;
     const countChanged = signalCount !== before.signal_count;
     if (!aliasesChanged && !countChanged && !patch.bodyChanged)
         return { ok: true, content, changed: false };
     const newline = content.includes("\r\n") ? "\r\n" : "\n";
     let lines = match[1].split(/\r?\n/);
-    if (aliasesChanged)
+    if (removed)
+        lines = replaceTopLevelKey(lines, "aliases", renderAliases(aliases));
+    else if (aliasesChanged)
         lines = appendAliases(lines, aliases, aliases.slice(before.aliases.length));
     if (lines && countChanged)
         lines = replaceTopLevelKey(lines, "signal_count", `signal_count: ${signalCount}`);

package/dist/lib/checkpoint-ontology/merge-copies.d.ts

@@ -27,16 +27,25 @@
  *
  * 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`) signal refs, invoice and
- * bill links, source and knowledge links are re-pointed at the survivor, the
- * survivor receives the copy's `external_ids` and `web_domains`, and only a
- * link from another copy or an external id conflict holds a pair.
+ * (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 { type OntologyCompany } from "./company.js";
 import { type EntityIndex } from "./tree.js";
@@ -46,14 +55,16 @@ export declare const MERGE_COPIES_FLAG = "checkpoint.ontology.merge-copies";
  * names differ only in spacing, case or punctuation (CO-65).
  */
 export declare const MERGE_VARIANTS_FLAG = "checkpoint.ontology.merge-variants";
+/** `merge-copies --listed`: merge exactly the reviewed `--only` pairs (CO-74). */
+export declare 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 declare const MERGE_REWRITE_REFS_FLAG = "checkpoint.ontology.merge-rewrite-refs";
-export type CopySkipReason = "no_original" | "original_invalid" | "identity_differs" | "not_in_duplicate_group" | "group_size" | "type_differs" | "names_differ" | "numbered_copy" | "not_listed";
-export type PairKind = "numbered" | "variants";
+export type CopySkipReason = "no_original" | "original_invalid" | "identity_differs" | "not_in_duplicate_group" | "group_size" | "type_differs" | "names_differ" | "numbered_copy" | "not_listed" | "listed_conflict";
+export type PairKind = "numbered" | "variants" | "listed";
 export interface CopySkip {
     copy: string;
     reason: CopySkipReason;
@@ -97,7 +108,7 @@ export interface CopyPlan extends CopyPair {
     /** Signal files whose `entity_refs` name the copy. */
     signal_refs: string[];
     /** Why the copy cannot be merged or deleted from here. */
-    held?: "signal_refs" | "linked_from_unwritable" | "merge_invalid" | "external_id_conflict";
+    held?: "signal_refs" | "linked_from_unwritable" | "merge_invalid" | "external_id_conflict" | "server_owned_refs";
     detail?: string;
     /** Keys added to the survivor. Set only when `rewriteRefs` is on. */
     add_external_ids?: string[];
@@ -133,7 +144,7 @@ export interface MergeCopiesReport {
     }[];
     /** Listed entries the finder did not produce. Absent unless `--only` was set. */
     only_unmatched?: ListedPair[];
-    /** Signal, source and knowledge files re-pointed at a survivor. Absent unless `rewriteRefs` was set. */
+    /** Knowledge files re-pointed at a survivor. Absent unless `rewriteRefs` was set. */
     rewritten?: string[];
     /** Entity-file links whose target file does not exist. */
     broken_links_before: number;
@@ -171,6 +182,14 @@ export declare function findVariantPairs(index: EntityIndex): {
     pairs: CopyPair[];
     skipped: CopySkip[];
 };
+/**
+ * The reviewed pairs themselves, for `pairKind: "listed"`. An entry is kept
+ * when both files are indexed entities of one writable type. Read-only.
+ */
+export declare function findListedPairs(index: EntityIndex, only: ListedPair[]): {
+    pairs: CopyPair[];
+    skipped: CopySkip[];
+};
 /**
  * Plan, merge or delete numbered copies for one company. The dry run writes
  * nothing; merge writes entity files only; delete removes vault keys and