@tenonhq/dovetail-core 0.0.125 → 0.0.127

package/dist/tests/envArg.test.js

@@ -1,26 +1,37 @@
 "use strict";
 // Tests for the per-command `--env` flag parser (envArg.ts). Covers the flag
 // spellings (--env, --env-file, --envFile, -e), `=` and space-separated forms,
-// last-wins precedence, absence, and absolute/relative path resolution.
+// last-wins precedence, absence, and resolution of bare instance names,
+// explicit env filenames, and relative/absolute paths.
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const envArg_1 = require("../envArg");
+// The conventional per-instance env-file prefix (`prod` → `<prefix>prod`).
+var ENV_PREFIX = ".env.";
 describe("parseEnvArg", function () {
     it("returns undefined when no env flag is present", function () {
         expect((0, envArg_1.parseEnvArg)(["push", "--diff", "main"])).toBeUndefined();
     });
     it("parses --env <path> (space-separated)", function () {
-        expect((0, envArg_1.parseEnvArg)(["push", "--env", ".env.prod"])).toBe(".env.prod");
+        expect((0, envArg_1.parseEnvArg)(["push", "--env", ENV_PREFIX + "prod"])).toBe(ENV_PREFIX + "prod");
+    });
+    it("parses --env <name> with a bare instance name", function () {
+        expect((0, envArg_1.parseEnvArg)(["refresh", "--env", "demo8"])).toBe("demo8");
     });
     it("parses --env=<path>", function () {
         expect((0, envArg_1.parseEnvArg)(["status", "--env=../envs/workshop.env"])).toBe("../envs/workshop.env");
     });
+    it("parses --env=<name> with a bare instance name", function () {
+        expect((0, envArg_1.parseEnvArg)(["push", "--env=demo8"])).toBe("demo8");
+    });
     it("parses the -e short alias (space and = forms)", function () {
-        expect((0, envArg_1.parseEnvArg)(["status", "-e", ".env.dev"])).toBe(".env.dev");
-        expect((0, envArg_1.parseEnvArg)(["status", "-e=.env.dev"])).toBe(".env.dev");
+        expect((0, envArg_1.parseEnvArg)(["status", "-e", ENV_PREFIX + "dev"])).toBe(ENV_PREFIX + "dev");
+        expect((0, envArg_1.parseEnvArg)(["status", "-e=" + ENV_PREFIX + "dev"])).toBe(ENV_PREFIX + "dev");
     });
     it("parses --env-file and --envFile spellings", function () {
         expect((0, envArg_1.parseEnvArg)(["push", "--env-file", "a.env"])).toBe("a.env");
@@ -29,21 +40,93 @@ describe("parseEnvArg", function () {
     it("takes the last occurrence when the flag is repeated", function () {
         expect((0, envArg_1.parseEnvArg)(["push", "--env", "first.env", "--env", "second.env"])).toBe("second.env");
     });
+    it("takes the last occurrence across mixed forms and spellings", function () {
+        expect((0, envArg_1.parseEnvArg)(["push", "--env=shop", "-e", "studio", "--env-file", "loft"])).toBe("loft");
+        expect((0, envArg_1.parseEnvArg)(["push", "-e", "studio", "--env=shop"])).toBe("shop");
+    });
     it("ignores a bare --env with no following value", function () {
         expect((0, envArg_1.parseEnvArg)(["push", "--env"])).toBeUndefined();
     });
     it("does not consume the next token when it looks like another flag", function () {
         expect((0, envArg_1.parseEnvArg)(["push", "--env", "--ci"])).toBeUndefined();
     });
-    it("treats an empty --env= as absent", function () {
+    it("treats an empty or whitespace-only --env= as absent", function () {
         expect((0, envArg_1.parseEnvArg)(["push", "--env="])).toBeUndefined();
+        expect((0, envArg_1.parseEnvArg)(["push", "--env=   "])).toBeUndefined();
+    });
+    it("returns undefined for a non-array argv", function () {
+        expect((0, envArg_1.parseEnvArg)(undefined)).toBeUndefined();
     });
 });
 describe("resolveEnvArgPath", function () {
+    var tmpDir;
+    beforeEach(function () {
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dove-envarg-"));
+    });
+    afterEach(function () {
+        fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+    });
     it("returns absolute paths unchanged", function () {
-        expect((0, envArg_1.resolveEnvArgPath)("/abs/path/.env", "/cwd")).toBe("/abs/path/.env");
+        var abs = path_1.default.join(tmpDir, "abs", ENV_PREFIX + "prod");
+        expect((0, envArg_1.resolveEnvArgPath)(abs, "/cwd")).toBe(abs);
+    });
+    it("resolves an absolute path that has no dot as a path, not a bare name", function () {
+        var abs = path_1.default.join(tmpDir, "creds");
+        expect((0, envArg_1.resolveEnvArgPath)(abs, "/cwd")).toBe(abs);
     });
     it("resolves relative paths against the provided cwd", function () {
-        expect((0, envArg_1.resolveEnvArgPath)(".env.prod", "/projects/sn")).toBe(path_1.default.join("/projects/sn", ".env.prod"));
+        expect((0, envArg_1.resolveEnvArgPath)("../envs/workshop.env", path_1.default.join(tmpDir, "repo"))).toBe(path_1.default.join(tmpDir, "envs", "workshop.env"));
+    });
+    it("treats a relative path without a dot in the basename as a path", function () {
+        expect((0, envArg_1.resolveEnvArgPath)(path_1.default.join("envs", "prod"), tmpDir)).toBe(path_1.default.join(tmpDir, "envs", "prod"));
+    });
+    it("uses an explicit env filename as-is (the file need not exist)", function () {
+        expect((0, envArg_1.resolveEnvArgPath)(ENV_PREFIX + "prod", tmpDir)).toBe(path_1.default.join(tmpDir, ENV_PREFIX + "prod"));
+    });
+    it("uses a dotted filename as-is even when it does not exist yet (dove login creates it)", function () {
+        expect((0, envArg_1.resolveEnvArgPath)("workshop.env", tmpDir)).toBe(path_1.default.join(tmpDir, "workshop.env"));
+    });
+    it("expands a bare instance name to the per-instance env file in cwd", function () {
+        expect((0, envArg_1.resolveEnvArgPath)("demo8", tmpDir)).toBe(path_1.default.join(tmpDir, ENV_PREFIX + "demo8"));
+    });
+    it("expands a bare name whether or not the target file exists", function () {
+        var target = path_1.default.join(tmpDir, ENV_PREFIX + "loft");
+        fs_1.default.writeFileSync(target, "");
+        expect((0, envArg_1.resolveEnvArgPath)("loft", tmpDir)).toBe(target);
+    });
+    it("prefers an existing literal file in cwd over bare-name expansion", function () {
+        var literal = path_1.default.join(tmpDir, "shop");
+        fs_1.default.writeFileSync(literal, "");
+        expect((0, envArg_1.resolveEnvArgPath)("shop", tmpDir)).toBe(literal);
+    });
+    it("does not treat a same-named directory as an existing literal file", function () {
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, "studio"));
+        expect((0, envArg_1.resolveEnvArgPath)("studio", tmpDir)).toBe(path_1.default.join(tmpDir, ENV_PREFIX + "studio"));
+    });
+    it("trims surrounding whitespace before resolving", function () {
+        expect((0, envArg_1.resolveEnvArgPath)("  demo8  ", tmpDir)).toBe(path_1.default.join(tmpDir, ENV_PREFIX + "demo8"));
+    });
+    it("resolves a bare name parsed from the --env= form end to end", function () {
+        var raw = (0, envArg_1.parseEnvArg)(["refresh", "--env=demo8"]);
+        expect(raw).toBe("demo8");
+        expect((0, envArg_1.resolveEnvArgPath)(raw, tmpDir)).toBe(path_1.default.join(tmpDir, ENV_PREFIX + "demo8"));
+    });
+    it("resolves the last-wins selection end to end", function () {
+        var raw = (0, envArg_1.parseEnvArg)(["push", "--env", ENV_PREFIX + "prod", "-e", "demo8"]);
+        expect((0, envArg_1.resolveEnvArgPath)(raw, tmpDir)).toBe(path_1.default.join(tmpDir, ENV_PREFIX + "demo8"));
+    });
+    it("defaults to process.cwd() when no cwd is given", function () {
+        expect((0, envArg_1.resolveEnvArgPath)("demo8")).toBe(path_1.default.resolve(process.cwd(), ENV_PREFIX + "demo8"));
+    });
+    it("throws on an empty or non-string selector", function () {
+        expect(function () {
+            (0, envArg_1.resolveEnvArgPath)("", tmpDir);
+        }).toThrow(/non-empty/);
+        expect(function () {
+            (0, envArg_1.resolveEnvArgPath)("   ", tmpDir);
+        }).toThrow(/non-empty/);
+        expect(function () {
+            (0, envArg_1.resolveEnvArgPath)(undefined, tmpDir);
+        }).toThrow(/non-empty/);
     });
 });

package/dist/tests/gitHead.test.js

@@ -0,0 +1,65 @@
+"use strict";
+// readGitHead backs the watcher's branch-switch guard. It must resolve the
+// HEAD commit inside a work tree and resolve null (never throw) elsewhere.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const gitHead_1 = require("../gitHead");
+describe("readGitHead", function () {
+    it("resolves the HEAD commit id inside a git work tree", async function () {
+        // This test file lives inside the repository's own work tree.
+        var head = await (0, gitHead_1.readGitHead)(__dirname);
+        expect(head).toMatch(/^[0-9a-f]{40}([0-9a-f]{24})?$/);
+    });
+    it("resolves null outside a git work tree", async function () {
+        var dir = fs.mkdtempSync(path.join(os.tmpdir(), "dove-githead-"));
+        try {
+            expect(await (0, gitHead_1.readGitHead)(dir)).toBeNull();
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("resolves null for a directory that does not exist", async function () {
+        var head = await (0, gitHead_1.readGitHead)(path.join(os.tmpdir(), "dove-githead-missing-" + Date.now()));
+        expect(head).toBeNull();
+    });
+    it("resolves null for an empty or non-string dir", async function () {
+        expect(await (0, gitHead_1.readGitHead)("")).toBeNull();
+        expect(await (0, gitHead_1.readGitHead)(undefined)).toBeNull();
+    });
+});

package/dist/tests/multi-scope-watcher.test.js

@@ -103,6 +103,11 @@ jest.mock("../logMessages", () => ({
 jest.mock("../recentEdits", () => ({
     writeRecentEdit: jest.fn(),
 }));
+// Branch-switch guard: default to "not a git work tree" (guard off) so the
+// existing tests keep today's behaviour; the guard block overrides it.
+jest.mock("../gitHead", () => ({
+    readGitHead: jest.fn().mockResolvedValue(null),
+}));
 jest.mock("../Logger", () => ({
     logger: {
         info: jest.fn(),
@@ -152,6 +157,7 @@ const ConfigManager = __importStar(require("../config"));
 const FileUtils_1 = require("../FileUtils");
 const appUtils_1 = require("../appUtils");
 const Logger_1 = require("../Logger");
+const gitHead_1 = require("../gitHead");
 const MultiScopeWatcher_1 = require("../MultiScopeWatcher");
 // Helper to flush microtask queue (for async code in setInterval callbacks)
 const flushPromises = () => new Promise((resolve) => setImmediate(resolve));
@@ -400,6 +406,77 @@ describe("MultiScopeWatcherManager", () => {
             expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("Watcher error: FS error"));
         });
     });
+    describe("branch-switch guard (git HEAD)", () => {
+        var HEAD_A = "a".repeat(40);
+        var HEAD_B = "b".repeat(40);
+        beforeEach(async () => {
+            ConfigManager.getConfig.mockReturnValue({
+                ...MOCK_CONFIG_TWO_SCOPES,
+                scopes: { x_test_core: { sourceDirectory: "src/x_test_core" } },
+            });
+            fs_1.default.existsSync.mockReturnValue(false);
+            FileUtils_1.getFileContextWithSkipReason.mockReturnValue({ context: makeFileContext() });
+            appUtils_1.groupAppFiles.mockReturnValue([{ table: "sys_script_include", sysId: "abc123", fields: {} }]);
+            appUtils_1.pushFiles.mockResolvedValue([{ success: true, message: "ok" }]);
+        });
+        afterEach(() => {
+            gitHead_1.readGitHead.mockReset();
+            gitHead_1.readGitHead.mockResolvedValue(null);
+        });
+        it("reads HEAD in the project root at start", async () => {
+            gitHead_1.readGitHead.mockResolvedValue(HEAD_A);
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)();
+            expect(gitHead_1.readGitHead).toHaveBeenCalledWith("/project");
+        });
+        it("pushes when HEAD is unchanged at flush time", async () => {
+            gitHead_1.readGitHead.mockResolvedValue(HEAD_A);
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)();
+            mockWatchers[0]._emit("change", makeFileContext().filePath);
+            await capturedDebounceFns[0]();
+            expect(gitHead_1.readGitHead).toHaveBeenCalledTimes(2);
+            expect(appUtils_1.pushFiles).toHaveBeenCalledTimes(1);
+            expect(Logger_1.logger.error).not.toHaveBeenCalledWith(expect.stringContaining("Git HEAD changed"));
+        });
+        it("drops the queue, pushes nothing, logs an error and pauses when HEAD moves between enqueue and flush", async () => {
+            gitHead_1.readGitHead.mockResolvedValue(HEAD_A);
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)();
+            mockWatchers[0]._emit("change", makeFileContext().filePath);
+            // A `git checkout` lands before the debounce fires.
+            gitHead_1.readGitHead.mockResolvedValue(HEAD_B);
+            await capturedDebounceFns[0]();
+            expect(appUtils_1.pushFiles).not.toHaveBeenCalled();
+            expect(mockSNClient.changeScope).not.toHaveBeenCalled();
+            expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("Git HEAD changed"));
+            expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("restart"));
+            var internals = MultiScopeWatcher_1.multiScopeWatcher;
+            expect(internals.pendingScopes.size).toBe(0);
+            internals.scopeWatchers.forEach(function (w) {
+                expect(w.pushQueue).toEqual([]);
+            });
+            // Paused: even if HEAD goes back, later changes are not pushed until restart.
+            gitHead_1.readGitHead.mockResolvedValue(HEAD_A);
+            mockWatchers[0]._emit("change", makeFileContext().filePath);
+            await capturedDebounceFns[0]();
+            expect(appUtils_1.pushFiles).not.toHaveBeenCalled();
+        });
+        it("treats an unreadable HEAD after start as a change (fail safe)", async () => {
+            gitHead_1.readGitHead.mockResolvedValue(HEAD_A);
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)();
+            mockWatchers[0]._emit("change", makeFileContext().filePath);
+            gitHead_1.readGitHead.mockResolvedValue(null);
+            await capturedDebounceFns[0]();
+            expect(appUtils_1.pushFiles).not.toHaveBeenCalled();
+            expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("unreadable"));
+        });
+        it("behaves as before outside a git work tree (no HEAD at start)", async () => {
+            gitHead_1.readGitHead.mockResolvedValue(null);
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)();
+            mockWatchers[0]._emit("change", makeFileContext().filePath);
+            await capturedDebounceFns[0]();
+            expect(gitHead_1.readGitHead).toHaveBeenCalledTimes(1);
+            expect(appUtils_1.pushFiles).toHaveBeenCalledTimes(1);
+        });
+    });
     describe("processScopeQueue - empty queue", () => {
         it("returns early when queue is empty", async () => {
             ConfigManager.getConfig.mockReturnValue({

package/dist/tests/pullRecord.test.js

@@ -517,6 +517,87 @@ describe("planPull — renamed record", function () {
         expect(plan.warnings.join("\n")).toMatch(/formatting differs/);
     });
 });
+describe("planPull — manifest key collisions (never overwrite another sys_id)", function () {
+    const TABLE = "sys_one_extend_capability";
+    const ID_DUP = "ddddddddddddddddddddddddddddddd4";
+    const NAME = "Skill Capability";
+    function metaFolder(key) {
+        return path.join(tmpRoot, "src", SCOPE, TABLE, key, "metaData.json");
+    }
+    test("two same-named metaData-only records pulled one after the other → both entries + both folders survive", async function () {
+        mockClient.getMissingFiles.mockResolvedValue(bulkDownload(TABLE, ID_META_ONLY, NAME, []));
+        await (0, pullRecord_1.applyPull)(await (0, pullRecord_1.planPull)([{ table: TABLE, sysId: ID_META_ONLY }]));
+        mockClient.getMissingFiles.mockResolvedValue(bulkDownload(TABLE, ID_DUP, NAME, []));
+        const plan = await (0, pullRecord_1.planPull)([{ table: TABLE, sysId: ID_DUP }]);
+        const dupKey = NAME + " (" + ID_DUP.substring(0, 8) + ")";
+        expect(plan.records[0].key).toBe(dupKey);
+        expect(plan.records[0].manifestAction).toBe("add");
+        await (0, pullRecord_1.applyPull)(plan);
+        const records = JSON.parse(readLocalManifest()).tables[TABLE].records;
+        expect(Object.keys(records)).toEqual([NAME, dupKey]);
+        expect(records[NAME].sys_id).toBe(ID_META_ONLY);
+        expect(records[dupKey]).toEqual({ files: [], name: dupKey, sys_id: ID_DUP });
+        expect(JSON.parse(fs.readFileSync(metaFolder(NAME), "utf8"))._sys_id).toBe(ID_META_ONLY);
+        expect(JSON.parse(fs.readFileSync(metaFolder(dupKey), "utf8"))._sys_id).toBe(ID_DUP);
+        // re-pulling either record is a no-op: the suffixed key is stable
+        const again = await (0, pullRecord_1.planPull)([{ table: TABLE, sysId: ID_DUP }]);
+        expect(again.records[0].key).toBe(dupKey);
+        expect(again.records[0].manifestAction).toBe("unchanged");
+        mockClient.getMissingFiles.mockResolvedValue(bulkDownload(TABLE, ID_META_ONLY, NAME, []));
+        const first = await (0, pullRecord_1.planPull)([{ table: TABLE, sysId: ID_META_ONLY }]);
+        expect(first.records[0].key).toBe(NAME);
+        expect(first.records[0].manifestAction).toBe("unchanged");
+    });
+    test("two same-named metaData-only records in ONE batch → both entries + both folders survive", async function () {
+        const a = bulkDownload(TABLE, ID_META_ONLY, NAME, [])[TABLE].records[NAME];
+        const b = bulkDownload(TABLE, ID_DUP, NAME, [])[TABLE].records[NAME];
+        mockClient.getMissingFiles.mockResolvedValue({ [TABLE]: { records: { [ID_META_ONLY]: a, [ID_DUP]: b } } });
+        const plan = await (0, pullRecord_1.planPull)([{ table: TABLE, sysId: ID_META_ONLY }, { table: TABLE, sysId: ID_DUP }]);
+        const dupKey = NAME + " (" + ID_DUP.substring(0, 8) + ")";
+        expect(plan.records.map(function (r) { return r.key + ":" + r.manifestAction; }))
+            .toEqual([NAME + ":add", dupKey + ":add"]);
+        await (0, pullRecord_1.applyPull)(plan);
+        const records = JSON.parse(readLocalManifest()).tables[TABLE].records;
+        expect(Object.keys(records)).toEqual([NAME, dupKey]);
+        expect(records[NAME].sys_id).toBe(ID_META_ONLY);
+        expect(records[dupKey].sys_id).toBe(ID_DUP);
+        expect(JSON.parse(fs.readFileSync(metaFolder(NAME), "utf8"))._sys_id).toBe(ID_META_ONLY);
+        expect(JSON.parse(fs.readFileSync(metaFolder(dupKey), "utf8"))._sys_id).toBe(ID_DUP);
+    });
+    test("a fallback key never takes a key the server manifest gives another record", async function () {
+        mockClient.getManifest.mockResolvedValue({
+            scope: SCOPE,
+            tables: { [TABLE]: { records: { [NAME]: { name: NAME, sys_id: ID_META_ONLY, files: [{ name: "script", type: "js" }] } } } },
+        });
+        mockClient.getMissingFiles.mockResolvedValue(bulkDownload(TABLE, ID_DUP, NAME, []));
+        const plan = await (0, pullRecord_1.planPull)([{ table: TABLE, sysId: ID_DUP }]);
+        expect(plan.records[0].key).toBe(NAME + " (" + ID_DUP.substring(0, 8) + ")");
+    });
+    test("a server-provided key held locally by a DIFFERENT sys_id → refused, points at dove refresh -t, writes nothing", async function () {
+        // Local manifest says "Sibling" is ID_SIB; the server now hands "Sibling" to
+        // another record (its duplicate-suffix order moved since the last refresh).
+        seedSibling();
+        writeLocalManifest(localManifestWithSibling(), true);
+        const before = snapshot(tmpRoot);
+        mockClient.getManifest.mockResolvedValue({
+            scope: SCOPE,
+            tables: { sys_script_include: { records: {
+                        Sibling: { name: "Sibling", sys_id: ID_NEW, files: [{ name: "script", type: "js" }] },
+                    } } },
+        });
+        await expect((0, pullRecord_1.planPull)([{ table: "sys_script_include", sysId: ID_NEW }]))
+            .rejects.toThrow(/manifest key 'Sibling' already belongs to sys_id aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1[\s\S]*dove refresh -t sys_script_include/);
+        expect(mockClient.getMissingFiles).not.toHaveBeenCalled();
+        expect(snapshot(tmpRoot)).toEqual(before);
+    });
+    test("spliceManifestRecord refuses to overwrite a key held by a different sys_id", function () {
+        expect(function () {
+            (0, pullRecord_1.spliceManifestRecord)(localManifestWithSibling(), SCOPE, "sys_script_include", {
+                files: [], name: "Sibling", sys_id: ID_NEW,
+            });
+        }).toThrow(/already belongs to sys_id/);
+    });
+});
 // ---------- --from-update-set ----------
 describe("targetsFromUpdateSet", function () {
     const SET = "d".repeat(32);

package/dist/tests/reconcileCreateGuard.test.js

@@ -0,0 +1,60 @@
+"use strict";
+// `dove reconcile --apply` creates net-new branch records through
+// snClient.createRecord. A sys_update_set record in the branch must not crash
+// the apply or be silently created in the session app: the createRecord guard
+// refuses it and the refusal surfaces as a named, per-record failure (which
+// applyMode lists and turns into exit code 1).
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock("../Logger", function () {
+    return {
+        logger: {
+            info: jest.fn(),
+            debug: jest.fn(),
+            warn: jest.fn(),
+            error: jest.fn(),
+            success: jest.fn(),
+            getLogLevel: function () { return "debug"; },
+        },
+    };
+});
+jest.mock("../FileLogger", function () {
+    return { fileLogger: { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() } };
+});
+jest.mock("../config", function () {
+    return {
+        getSourcePathForScope: function () {
+            return "/nonexistent-reconcile-source";
+        },
+    };
+});
+var mockPost = jest.fn();
+jest.mock("../snClient", function () {
+    var actual = jest.requireActual("../snClient");
+    var client = actual.snClient("https://x.service-now.com/", "u", "p");
+    client.client.post = mockPost;
+    return Object.assign({}, actual, {
+        defaultClient: function () {
+            return client;
+        },
+    });
+});
+const reconcileCommand_1 = require("../reconcileCommand");
+describe("reconcile applyCreates with a sys_update_set record", function () {
+    it("reports a clear per-record failure and never posts", async function () {
+        var change = {
+            kind: "create",
+            table: "sys_update_set",
+            scope: "x_s",
+            sys_id: "abc123",
+            name: "Foo",
+            fieldDeltas: [],
+        };
+        var outcomes = await (0, reconcileCommand_1.applyCreates)("x_s", [change], "us1");
+        expect(outcomes).toHaveLength(1);
+        expect(outcomes[0].ok).toBe(false);
+        expect(outcomes[0].change.sys_id).toBe("abc123");
+        expect(outcomes[0].error).toMatch(/Refusing to insert sys_update_set/);
+        expect(outcomes[0].error).toMatch(/dove createUpdateSet/);
+        expect(mockPost).not.toHaveBeenCalled();
+    });
+});

package/dist/tests/refreshFailedScopes.test.js

@@ -0,0 +1,194 @@
+"use strict";
+/**
+ * `dove refresh` must fail loudly when a scope fails.
+ *
+ * Regression target: against an instance without the sync API, every scope's
+ * getManifest returned HTTP 400, each failure was caught and logged inside
+ * syncManifest, and refreshCommand still printed "Refresh complete!" and
+ * exited 0 — so scripts and CI read a total failure as success.
+ *
+ * Contract pinned here:
+ *   1. An all-scopes refresh keeps going past a failed scope (the rest still
+ *      refresh) and returns every failure in `failedScopes`.
+ *   2. refreshCommand prints a per-scope failure summary, sets a non-zero exit
+ *      code, and does NOT print "Refresh complete!".
+ *   3. A clean refresh still prints "Refresh complete!" and leaves the exit
+ *      code alone.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var mockLogger = {
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    success: jest.fn(),
+    setLogLevel: jest.fn(),
+    getLogLevel: function () { return "info"; },
+};
+var mockClient = {
+    getManifest: jest.fn(),
+    getMissingFiles: jest.fn().mockResolvedValue({}),
+};
+var mockFUtils = {
+    writeScopeManifest: jest.fn().mockResolvedValue(undefined),
+    writeFileForce: jest.fn().mockResolvedValue(undefined),
+    writeSNFileCurry: jest.fn(() => jest.fn().mockResolvedValue(undefined)),
+    createDirRecursively: jest.fn().mockResolvedValue(undefined),
+};
+jest.mock("../Logger", function () { return { logger: mockLogger }; });
+jest.mock("../FileLogger", function () {
+    return { fileLogger: { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() } };
+});
+jest.mock("../FileUtils", function () { return mockFUtils; });
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: function () { return mockClient; },
+        unwrapSNResponse: function (p) { return Promise.resolve(p); },
+        processPushResponse: jest.fn(),
+        retryOnErr: jest.fn(),
+        retryOnHttpErr: jest.fn(),
+        unwrapTableAPIFirstItem: jest.fn(),
+    };
+});
+var mockConfig = {
+    getConfig: jest.fn(),
+    getManifest: jest.fn(),
+    getSourcePathForScope: jest.fn().mockReturnValue("/tmp/src"),
+    getSourcePath: jest.fn().mockReturnValue("/tmp/src"),
+    getManifestPath: jest.fn().mockReturnValue("/tmp/dove.manifest.json"),
+    resolveConfigForScope: jest.fn().mockReturnValue({
+        tables: ["sys_script_include"],
+        fieldOverrides: {},
+        apiIncludes: {},
+        apiExcludes: {},
+    }),
+    isMultiScopeManifest: jest.fn().mockReturnValue(true),
+    updateManifest: jest.fn(),
+};
+jest.mock("../config", function () { return mockConfig; });
+jest.mock("progress", function () {
+    return jest.fn().mockImplementation(function () { return { tick: jest.fn() }; });
+});
+const AppUtils = __importStar(require("../appUtils"));
+const commands_1 = require("../commands");
+var SCOPES = ["x_cadso_core", "x_cadso_work", "x_cadso_journey"];
+function declareScopes() {
+    var scopes = {};
+    var manifest = {};
+    SCOPES.forEach(function (s) {
+        scopes[s] = {};
+        manifest[s] = { scope: s, tables: {} };
+    });
+    mockConfig.getConfig.mockReturnValue({ scopes: scopes });
+    mockConfig.getManifest.mockResolvedValue(manifest);
+}
+function errorLines() {
+    return mockLogger.error.mock.calls.map(function (c) { return String(c[0]); });
+}
+describe("syncManifest — failed scopes are collected, not swallowed", function () {
+    beforeEach(function () {
+        jest.clearAllMocks();
+        mockConfig.isMultiScopeManifest.mockReturnValue(true);
+        declareScopes();
+    });
+    test("keeps refreshing past a failed scope and reports it", async function () {
+        mockClient.getManifest.mockImplementation(function (scope) {
+            if (scope === "x_cadso_work") {
+                return Promise.reject(new Error("HTTP 400 from api/cadso/dovetail_sync/getManifest/x_cadso_work"));
+            }
+            return Promise.resolve({ scope: scope, tables: {} });
+        });
+        var result = await AppUtils.syncManifest();
+        var attempted = mockClient.getManifest.mock.calls.map(function (c) { return c[0]; });
+        expect(attempted).toEqual(SCOPES);
+        expect(result.failedScopes).toHaveLength(1);
+        expect(result.failedScopes[0].scope).toBe("x_cadso_work");
+        expect(result.failedScopes[0].error).toContain("HTTP 400");
+        // The scopes either side of the failure still wrote their manifests.
+        expect(mockFUtils.writeScopeManifest).toHaveBeenCalledTimes(2);
+    });
+    test("every scope failing reports every scope", async function () {
+        mockClient.getManifest.mockRejectedValue(new Error("HTTP 400"));
+        var result = await AppUtils.syncManifest();
+        expect(result.failedScopes.map(function (f) { return f.scope; })).toEqual(SCOPES);
+    });
+    test("a clean refresh reports no failures", async function () {
+        mockClient.getManifest.mockImplementation(function (scope) {
+            return Promise.resolve({ scope: scope, tables: {} });
+        });
+        var result = await AppUtils.syncManifest();
+        expect(result.failedScopes).toEqual([]);
+    });
+    test("a top-level failure (no manifest) is reported too", async function () {
+        mockConfig.getManifest.mockResolvedValue(undefined);
+        var result = await AppUtils.syncManifest();
+        expect(result.failedScopes).toHaveLength(1);
+        expect(result.failedScopes[0].error).toContain("No manifest file loaded");
+    });
+});
+describe("refreshCommand — exit code reflects failed scopes", function () {
+    var originalExitCode;
+    beforeEach(function () {
+        jest.clearAllMocks();
+        originalExitCode = process.exitCode;
+        process.exitCode = undefined;
+    });
+    afterEach(function () {
+        process.exitCode = originalExitCode;
+        jest.restoreAllMocks();
+    });
+    test("failed scopes → summary, non-zero exit, no 'Refresh complete!'", async function () {
+        jest.spyOn(AppUtils, "syncManifest").mockResolvedValue({
+            failedScopes: [
+                { scope: "x_cadso_core", error: "HTTP 400" },
+                { scope: "x_cadso_work", error: "HTTP 400" },
+            ],
+        });
+        await (0, commands_1.refreshCommand)({});
+        expect(process.exitCode).toBe(1);
+        expect(mockLogger.success).not.toHaveBeenCalled();
+        var lines = errorLines();
+        expect(lines.some(function (l) { return l.indexOf("2 failed scopes") !== -1; })).toBe(true);
+        expect(lines.some(function (l) { return l.indexOf("x_cadso_core: HTTP 400") !== -1; })).toBe(true);
+        expect(lines.some(function (l) { return l.indexOf("x_cadso_work: HTTP 400") !== -1; })).toBe(true);
+    });
+    test("clean refresh → 'Refresh complete!' and exit code untouched", async function () {
+        jest.spyOn(AppUtils, "syncManifest").mockResolvedValue({ failedScopes: [] });
+        await (0, commands_1.refreshCommand)({});
+        expect(process.exitCode).toBeUndefined();
+        expect(mockLogger.success).toHaveBeenCalledWith("Refresh complete!");
+    });
+});