@tenonhq/dovetail-core 0.0.104 → 0.0.106

package/dist/reconcileCommand.js

@@ -0,0 +1,571 @@
+"use strict";
+// `dove reconcile` — make a developer's personal ServiceNow instance match the
+// git branch they just checked out: the deliberate, diff-gated inverse of
+// `dove watch`.
+//
+// Modes:
+//   (default)          read-only dry run — snapshot branch (on-disk) + live
+//                      instance, classify create/update/delete, surface drift,
+//                      report schema drift (report-only), print the report.
+//   --write-baseline   establish the per-instance merge-base from current live
+//                      state (no record changes). Run this once before --apply.
+//   --apply [--force]  apply records branch -> instance: CREATE net-new (with
+//                      the branch's own sys_id, which the server honors),
+//                      UPDATE changed records, DELETE tracked instance-only
+//                      records. Refuses if the instance drifted since baseline
+//                      (unless --force). Schema stays report-only (a SN ceiling).
+//                      Updates for a scope with no configured update set are
+//                      skipped, not pushed — a raw PATCH would re-parent scope.
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reconcileCommand = reconcileCommand;
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_1 = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const dovetail_schema_1 = require("@tenonhq/dovetail-schema");
+const Logger_1 = require("./Logger");
+const FileLogger_1 = require("./FileLogger");
+const commands_1 = require("./commands");
+const ConfigManager = __importStar(require("./config"));
+const snClient_1 = require("./snClient");
+const appUtils_1 = require("./appUtils");
+const projectFiles_1 = require("./projectFiles");
+const recordSource_1 = require("./reconcile/recordSource");
+const recordDiff_1 = require("./reconcile/recordDiff");
+const fields_1 = require("./reconcile/fields");
+const baseline_1 = require("./reconcile/baseline");
+const report_1 = require("./reconcile/report");
+const applyPlan_1 = require("./reconcile/applyPlan");
+const multiPass_1 = require("./reconcile/multiPass");
+const gitignore_1 = require("./reconcile/gitignore");
+// Per-scope update-set routing, read from the same .dove-update-sets.json the
+// push pipeline uses. Missing/parse errors degrade to {} (treated as "no update
+// set configured"), never throw.
+function getUpdateSetConfig() {
+    try {
+        const configPath = (0, projectFiles_1.getUpdateSetsConfigPath)();
+        if (fs_1.default.existsSync(configPath)) {
+            const parsed = JSON.parse(fs_1.default.readFileSync(configPath, "utf8"));
+            if (parsed && typeof parsed === "object") {
+                return parsed;
+            }
+        }
+    }
+    catch (e) {
+        FileLogger_1.fileLogger.debug("reconcile: could not read update-set config");
+    }
+    return {};
+}
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+function requireCreds() {
+    const { SN_USER = "", SN_PASSWORD = "", SN_INSTANCE = "" } = process.env;
+    if (!SN_USER || !SN_PASSWORD || !SN_INSTANCE) {
+        throw new Error("Missing ServiceNow credentials. Ensure SN_INSTANCE, SN_USER, and SN_PASSWORD are set in your .env file or environment.");
+    }
+    return { SN_USER, SN_PASSWORD, SN_INSTANCE };
+}
+function normalizeInstance(instance) {
+    return instance.replace(/^https?:\/\//, "").replace(/\/$/, "");
+}
+function resolveScopes(args) {
+    const config = ConfigManager.getConfig();
+    const configScopes = config.scopes ? Object.keys(config.scopes) : [];
+    if (configScopes.length === 0) {
+        throw new Error("No scopes configured in dove.config.js. Add scopes to the 'scopes' object in your configuration.");
+    }
+    if (args.scope) {
+        if (configScopes.indexOf(args.scope) === -1) {
+            throw new Error('Scope "' +
+                args.scope +
+                '" is not configured in dove.config.js. Available scopes: ' +
+                configScopes.join(", "));
+        }
+        return [args.scope];
+    }
+    return configScopes;
+}
+async function currentBranch() {
+    try {
+        const { stdout } = await execFileAsync("git", ["rev-parse", "--abbrev-ref", "HEAD"]);
+        return stdout.trim();
+    }
+    catch (e) {
+        return "";
+    }
+}
+// Best-effort schema arm: only runs when a snapshot exists for this instance.
+async function buildSchemaDiffs(options) {
+    const { creds, instance, scopes } = options;
+    const rootDir = ConfigManager.getRootDir();
+    const outputDir = path_1.default.join(rootDir, "schema");
+    let snapshots = [];
+    try {
+        snapshots = await (0, dovetail_schema_1.listSnapshots)({ outputDir, instance });
+    }
+    catch (e) {
+        return { diffs: {}, skipped: "schema snapshot lookup failed" };
+    }
+    if (snapshots.length === 0) {
+        return {
+            diffs: {},
+            skipped: "no schema snapshot for " +
+                instance +
+                " — run `dove schema pull --snapshot <label>` to include schema drift",
+        };
+    }
+    const fromRef = path_1.default.basename(snapshots[0].dir);
+    let liveDir;
+    try {
+        const tmpDir = await fs_1.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "dove-reconcile-schema-"));
+        await (0, dovetail_schema_1.pullSchema)({
+            instance: creds.SN_INSTANCE,
+            username: creds.SN_USER,
+            password: creds.SN_PASSWORD,
+            outputDir: tmpDir,
+            scopes,
+        });
+        liveDir = tmpDir;
+    }
+    catch (e) {
+        return { diffs: {}, skipped: "live schema pull failed" };
+    }
+    const fromDir = await (0, dovetail_schema_1.resolveSnapshotDir)({ ref: fromRef, outputDir, instance });
+    const diffs = {};
+    for (const scope of scopes) {
+        try {
+            const from = await (0, dovetail_schema_1.readSchemaTree)({ dir: fromDir, scope });
+            const to = await (0, dovetail_schema_1.readSchemaTree)({ dir: liveDir, scope });
+            diffs[scope] = (0, dovetail_schema_1.diffSchemas)({ from, to, fromRef, toRef: "live", scope });
+        }
+        catch (e) {
+            FileLogger_1.fileLogger.debug("reconcile: schema diff failed for scope " + scope);
+        }
+    }
+    return { diffs, skipped: null };
+}
+// Collect the on-disk field file paths for the records an apply will UPDATE, so
+// the existing build + update-set push pipeline can overwrite the instance with
+// branch content.
+async function collectUpdateFilePaths(scope, updates) {
+    const sourcePath = ConfigManager.getSourcePathForScope(scope);
+    const paths = [];
+    for (const change of updates) {
+        const recordDir = path_1.default.join(sourcePath, change.table, change.name);
+        let entries;
+        try {
+            entries = await fs_1.promises.readdir(recordDir);
+        }
+        catch (e) {
+            FileLogger_1.fileLogger.debug("reconcile: update record dir missing " + recordDir);
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry === "metaData.json") {
+                continue;
+            }
+            const full = path_1.default.join(recordDir, entry);
+            try {
+                const stat = await fs_1.promises.stat(full);
+                if (stat.isFile()) {
+                    paths.push(full);
+                }
+            }
+            catch (e) {
+                // ignore unreadable entry
+            }
+        }
+    }
+    return paths;
+}
+async function applyUpdates(scope, updates) {
+    if (updates.length === 0) {
+        return { pushed: 0, failures: [] };
+    }
+    const paths = await collectUpdateFilePaths(scope, updates);
+    if (paths.length === 0) {
+        return { pushed: 0, failures: [] };
+    }
+    const recs = await (0, appUtils_1.getAppFileList)(paths);
+    const results = await (0, appUtils_1.pushFiles)(recs);
+    const failures = [];
+    let pushed = 0;
+    for (const result of results) {
+        if (result.success) {
+            pushed++;
+        }
+        else {
+            failures.push(result.message);
+        }
+    }
+    return { pushed, failures };
+}
+async function applyDeletes(scope, deletes) {
+    if (deletes.length === 0) {
+        return [];
+    }
+    const client = (0, snClient_1.defaultClient)();
+    return (0, multiPass_1.runMultiPassOps)(deletes, async (change) => {
+        try {
+            const response = await client.deleteRecord({
+                table: change.table,
+                sys_id: change.sys_id,
+                scope,
+            });
+            let data = response.data;
+            if (data && data.result) {
+                data = data.result;
+            }
+            if (data && (data.error || data.success === false)) {
+                return { ok: false, error: data.error || "delete rejected" };
+            }
+            return { ok: true };
+        }
+        catch (e) {
+            return { ok: false, error: e instanceof Error ? e.message : String(e) };
+        }
+    });
+}
+// Reconstruct the full field set for a CREATE from the record's on-disk
+// representation: the metaData.json snapshot supplies every captured field
+// value, then the canonical field files (script.js, etc.) override their own
+// fields. Volatile bookkeeping and identity columns are excluded — sys_id is
+// passed separately (and honored by the server), sys_scope comes from `scope`.
+async function buildCreateFields(scope, change) {
+    const sourcePath = ConfigManager.getSourcePathForScope(scope);
+    const recordDir = path_1.default.join(sourcePath, change.table, change.name);
+    const fields = {};
+    // 1. metaData snapshot — short/non-file fields (active, order, name, ...).
+    try {
+        const metaRaw = await fs_1.promises.readFile(path_1.default.join(recordDir, "metaData.json"), "utf8");
+        const meta = JSON.parse(metaRaw);
+        for (const key of Object.keys(meta)) {
+            if (key.charAt(0) === "_" || key === "sys_id" || key === "sys_scope") {
+                continue;
+            }
+            if (key.indexOf("sys_") === 0) {
+                // sys_created_on/by, sys_updated_on/by, sys_mod_count, sys_class_name, ...
+                // Skipped: server-managed. (sys_class_name on a base table defaults fine.)
+                continue;
+            }
+            const value = meta[key];
+            if (typeof value === "string") {
+                fields[key] = value;
+            }
+            else if (typeof value === "object" &&
+                value !== null &&
+                typeof value.value === "string") {
+                fields[key] = value.value;
+            }
+        }
+    }
+    catch (e) {
+        FileLogger_1.fileLogger.debug("reconcile: no metaData for create " + recordDir);
+    }
+    // 2. Canonical field files override (the authoritative large-field content).
+    let entries = [];
+    try {
+        entries = await fs_1.promises.readdir(recordDir);
+    }
+    catch (e) {
+        FileLogger_1.fileLogger.debug("reconcile: create record dir missing " + recordDir);
+    }
+    for (const entry of entries) {
+        if (entry === "metaData.json") {
+            continue;
+        }
+        const dot = entry.lastIndexOf(".");
+        if (dot <= 0) {
+            continue;
+        }
+        const name = entry.slice(0, dot);
+        const type = entry.slice(dot + 1);
+        if (!(0, fields_1.isComparableField)({ name, type })) {
+            continue;
+        }
+        try {
+            const stat = await fs_1.promises.stat(path_1.default.join(recordDir, entry));
+            if (stat.isFile()) {
+                fields[name] = await fs_1.promises.readFile(path_1.default.join(recordDir, entry), "utf8");
+            }
+        }
+        catch (e) {
+            // ignore unreadable entry
+        }
+    }
+    // Ensure a name is present (some tables require it).
+    if (!fields.name && change.name) {
+        fields.name = change.name;
+    }
+    return fields;
+}
+async function applyCreates(scope, creates, updateSetSysId) {
+    if (creates.length === 0) {
+        return [];
+    }
+    const client = (0, snClient_1.defaultClient)();
+    return (0, multiPass_1.runMultiPassOps)(creates, async (change) => {
+        try {
+            const fields = await buildCreateFields(scope, change);
+            const response = await client.createRecord({
+                table: change.table,
+                fields,
+                sys_id: change.sys_id,
+                scope,
+                update_set_sys_id: updateSetSysId,
+            });
+            let data = response.data;
+            if (data && data.result) {
+                data = data.result;
+            }
+            if (data && data.error) {
+                return { ok: false, error: data.error };
+            }
+            if (data && data.sys_id && data.sys_id !== change.sys_id) {
+                // The server reassigned the sys_id — identity would diverge and the
+                // diff would never converge. Surface it loudly rather than silently
+                // creating a phantom.
+                return {
+                    ok: false,
+                    error: "server reassigned sys_id (" + data.sys_id + " != " + change.sys_id + ")",
+                };
+            }
+            return { ok: true };
+        }
+        catch (e) {
+            return { ok: false, error: e instanceof Error ? e.message : String(e) };
+        }
+    });
+}
+// Capture current live state across every scope into a fresh baseline + ensure
+// the baseline file is gitignored in the consumer project.
+async function recaptureBaseline(options) {
+    const all = [];
+    for (const scope of options.scopes) {
+        try {
+            const live = await (0, recordSource_1.loadLiveRecords)(scope);
+            for (const record of live) {
+                all.push(record);
+            }
+        }
+        catch (e) {
+            Logger_1.logger.warn("Baseline capture failed for scope " + scope + " — skipped.");
+        }
+    }
+    (0, baseline_1.writeBaseline)(options.rootDir, (0, baseline_1.baselineFromLive)(options.instance, all));
+    const update = (0, gitignore_1.ensureGitignored)(options.rootDir, baseline_1.BASELINE_FILENAME);
+    if (update.changed) {
+        Logger_1.logger.info("Added " + baseline_1.BASELINE_FILENAME + " to .gitignore.");
+    }
+    return all.length;
+}
+async function writeBaselineMode(options) {
+    Logger_1.logger.info("Establishing reconcile baseline for " + options.instance + "...");
+    const count = await recaptureBaseline(options);
+    Logger_1.logger.success("Baseline established: " + count + " record(s) captured to " + baseline_1.BASELINE_FILENAME + ".");
+}
+async function reconcileCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    const typedArgs = args;
+    let creds;
+    try {
+        creds = requireCreds();
+    }
+    catch (e) {
+        Logger_1.logger.error(e instanceof Error ? e.message : String(e));
+        process.exitCode = 1;
+        return;
+    }
+    const instance = normalizeInstance(creds.SN_INSTANCE);
+    const scopes = resolveScopes(typedArgs);
+    const rootDir = ConfigManager.getRootDir();
+    // --write-baseline: establish the merge-base and stop.
+    if (typedArgs.writeBaseline) {
+        await writeBaselineMode({ rootDir, instance, scopes });
+        return;
+    }
+    const branchRef = await currentBranch();
+    const baseline = (0, baseline_1.readBaseline)(rootDir, instance);
+    const baselineIds = (0, baseline_1.baselineSysIds)(baseline);
+    // Schema arm is on by default; --no-schema disables it.
+    let schemaDiffs = {};
+    let schemaSkippedReason = null;
+    if (typedArgs.schema === false) {
+        schemaSkippedReason = "schema diff disabled (--no-schema)";
+    }
+    else {
+        const schemaResult = await buildSchemaDiffs({ creds, instance, scopes });
+        schemaDiffs = schemaResult.diffs;
+        schemaSkippedReason = schemaResult.skipped;
+    }
+    const scopeData = [];
+    const scopeResults = [];
+    for (const scope of scopes) {
+        Logger_1.logger.info("Reconciling scope: " + scope + "...");
+        let branch;
+        let live;
+        try {
+            branch = await (0, recordSource_1.loadBranchRecords)(scope);
+            live = await (0, recordSource_1.loadLiveRecords)(scope);
+        }
+        catch (e) {
+            Logger_1.logger.error("Failed to load records for scope " +
+                scope +
+                ": " +
+                (e instanceof Error ? e.message : String(e)));
+            continue;
+        }
+        const diff = (0, recordDiff_1.diffRecords)({ branch, live, baselineSysIds: baselineIds });
+        const dirty = (0, baseline_1.computeDirty)({ baseline, live });
+        scopeData.push({ scope, live, diff, dirty });
+        scopeResults.push({
+            scope,
+            diff,
+            dirty,
+            hasBaseline: baseline !== null,
+            schema: schemaDiffs[scope] || null,
+        });
+    }
+    const report = (0, report_1.formatReconcileReport)({
+        instanceHost: instance,
+        branchRef,
+        scopes: scopeResults,
+        schemaSkippedReason,
+    });
+    // console.log so the report's own layout survives the winston line-wrapper.
+    console.log(report);
+    if (!typedArgs.apply) {
+        return;
+    }
+    await applyMode({ typedArgs, scopeData, baseline: baseline !== null, rootDir, instance, scopes });
+}
+async function applyMode(options) {
+    const { typedArgs, scopeData } = options;
+    const force = typedArgs.force === true;
+    const plans = scopeData.map((data) => ({
+        scope: data.scope,
+        plan: (0, applyPlan_1.buildApplyPlan)({
+            diff: data.diff,
+            dirty: data.dirty,
+            hasBaseline: options.baseline,
+            force,
+        }),
+    }));
+    const refused = plans.filter((entry) => entry.plan.refuse);
+    if (refused.length > 0) {
+        Logger_1.logger.error("Apply refused:");
+        for (const entry of refused) {
+            Logger_1.logger.error("  [" + entry.scope + "] " + entry.plan.refuseReason);
+        }
+        process.exitCode = 1;
+        return;
+    }
+    Logger_1.logger.info("");
+    Logger_1.logger.info("Applying reconcile (branch -> instance)...");
+    const updateSetConfig = getUpdateSetConfig();
+    let totalCreated = 0;
+    let totalUpdated = 0;
+    let totalDeleted = 0;
+    const failures = [];
+    for (const entry of plans) {
+        const { scope, plan } = entry;
+        const updateSet = updateSetConfig[scope];
+        const updateSetSysId = updateSet ? updateSet.sys_id : undefined;
+        // CREATE — scope-correct via the `scope` param; routed into the update set
+        // when one is configured.
+        const createOutcomes = await applyCreates(scope, plan.creates, updateSetSysId);
+        for (const outcome of createOutcomes) {
+            if (outcome.ok) {
+                totalCreated++;
+            }
+            else {
+                failures.push("[" + scope + "] create " + outcome.change.table + "/" + outcome.change.name + ": " + (outcome.error || "failed"));
+            }
+        }
+        // UPDATE — guard against the re-parenting trap: pushFiles falls back to a
+        // raw PATCH (which adopts session scope) when no update set is configured.
+        // Refuse to push updates for such a scope rather than silently re-parent.
+        if (plan.updates.length > 0 && !updateSetSysId) {
+            failures.push("[" +
+                scope +
+                "] " +
+                plan.updates.length +
+                " update(s) skipped — no update set configured for this scope. " +
+                "Set one (e.g. `dove switchUpdateSet`) before applying updates, to avoid re-parenting scope.");
+        }
+        else {
+            const updateResult = await applyUpdates(scope, plan.updates);
+            totalUpdated += updateResult.pushed;
+            for (const failure of updateResult.failures) {
+                failures.push("[" + scope + "] update: " + failure);
+            }
+        }
+        // DELETE — tracked instance-only records.
+        const deleteOutcomes = await applyDeletes(scope, plan.deletes);
+        for (const outcome of deleteOutcomes) {
+            if (outcome.ok) {
+                totalDeleted++;
+            }
+            else {
+                failures.push("[" + scope + "] delete " + outcome.change.table + "/" + outcome.change.name + ": " + (outcome.error || "failed"));
+            }
+        }
+    }
+    // Re-capture the baseline from the now-converged instance.
+    await recaptureBaseline({
+        rootDir: options.rootDir,
+        instance: options.instance,
+        scopes: options.scopes,
+    });
+    Logger_1.logger.info("");
+    Logger_1.logger.success("Applied: " +
+        totalCreated +
+        " created, " +
+        totalUpdated +
+        " updated, " +
+        totalDeleted +
+        " deleted.");
+    if (failures.length > 0) {
+        Logger_1.logger.error(failures.length + " operation(s) failed:");
+        for (const failure of failures) {
+            Logger_1.logger.error("  " + failure);
+        }
+        process.exitCode = 1;
+    }
+}

package/dist/tests/reconcileApplyPlan.test.js

@@ -0,0 +1,98 @@
+"use strict";
+// Tests for the pure apply-plan decision: refuse-if-dirty, baseline gating,
+// --force semantics, and delete eligibility by disposition.
+Object.defineProperty(exports, "__esModule", { value: true });
+const applyPlan_1 = require("../reconcile/applyPlan");
+const change = (over) => ({
+    table: "sys_script",
+    scope: "x_cadso_core",
+    name: over.sys_id,
+    fieldDeltas: [],
+    ...over,
+});
+const diff = (over) => ({
+    creates: [],
+    updates: [],
+    deletes: [],
+    unchangedCount: 0,
+    ...over,
+});
+const dirty = (sys_id) => ({
+    sys_id,
+    table: "sys_script",
+    name: sys_id,
+    reason: "changed-since-baseline",
+});
+describe("buildApplyPlan — refusal gating", () => {
+    it("refuses with no baseline", () => {
+        const plan = (0, applyPlan_1.buildApplyPlan)({ diff: diff({}), dirty: [], hasBaseline: false, force: false });
+        expect(plan.refuse).toBe(true);
+        expect(plan.refuseReason).toContain("--write-baseline");
+    });
+    it("refuses on drift without --force", () => {
+        const plan = (0, applyPlan_1.buildApplyPlan)({
+            diff: diff({}),
+            dirty: [dirty("a")],
+            hasBaseline: true,
+            force: false,
+        });
+        expect(plan.refuse).toBe(true);
+        expect(plan.refuseReason).toContain("changed on the instance since baseline");
+    });
+    it("does not refuse on drift with --force", () => {
+        const plan = (0, applyPlan_1.buildApplyPlan)({
+            diff: diff({}),
+            dirty: [dirty("a")],
+            hasBaseline: true,
+            force: true,
+        });
+        expect(plan.refuse).toBe(false);
+    });
+    it("does not refuse when clean", () => {
+        const plan = (0, applyPlan_1.buildApplyPlan)({ diff: diff({}), dirty: [], hasBaseline: true, force: false });
+        expect(plan.refuse).toBe(false);
+    });
+});
+describe("buildApplyPlan — what applies", () => {
+    it("includes updates and creates", () => {
+        const plan = (0, applyPlan_1.buildApplyPlan)({
+            diff: diff({
+                updates: [change({ sys_id: "u", kind: "update" })],
+                creates: [change({ sys_id: "c", kind: "create" })],
+            }),
+            dirty: [],
+            hasBaseline: true,
+            force: false,
+        });
+        expect(plan.updates.map((u) => u.sys_id)).toEqual(["u"]);
+        expect(plan.creates.map((c) => c.sys_id)).toEqual(["c"]);
+    });
+    it("applies only tracked deletes; keeps local-new and no-baseline", () => {
+        const plan = (0, applyPlan_1.buildApplyPlan)({
+            diff: diff({
+                deletes: [
+                    change({ sys_id: "t", kind: "delete", deleteDisposition: "tracked" }),
+                    change({ sys_id: "l", kind: "delete", deleteDisposition: "local-new" }),
+                    change({ sys_id: "n", kind: "delete", deleteDisposition: "no-baseline" }),
+                ],
+            }),
+            dirty: [],
+            hasBaseline: true,
+            force: false,
+        });
+        expect(plan.deletes.map((d) => d.sys_id)).toEqual(["t"]);
+        expect(plan.skippedDeletes.map((d) => d.sys_id).sort()).toEqual(["l", "n"]);
+    });
+    it("--force still never deletes local-new records", () => {
+        const plan = (0, applyPlan_1.buildApplyPlan)({
+            diff: diff({
+                deletes: [change({ sys_id: "mine", kind: "delete", deleteDisposition: "local-new" })],
+            }),
+            dirty: [dirty("other")],
+            hasBaseline: true,
+            force: true,
+        });
+        expect(plan.deletes).toHaveLength(0);
+        expect(plan.skippedDeletes.map((d) => d.sys_id)).toEqual(["mine"]);
+    });
+});