@tenonhq/dovetail-core 0.0.124 → 0.0.126

package/dist/pullRecordCommand.js

@@ -0,0 +1,161 @@
+"use strict";
+/**
+ * `dove pull <table> <sysId...>` — the per-record form of pull. See
+ * pullRecord.ts for the engine; this file is the CLI surface: argument
+ * normalization, the dry-run report, and the summary.
+ *
+ * A bare `dove pull` (no table, no --from-update-set) is still the historic
+ * alias of `dove refresh`; commander.ts routes that case before reaching here.
+ */
+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.collectTargets = collectTargets;
+exports.pullRecordCommand = pullRecordCommand;
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const Logger_1 = require("./Logger");
+const FileLogger_1 = require("./FileLogger");
+const commands_1 = require("./commands");
+const ConfigManager = __importStar(require("./config"));
+const pullRecord_1 = require("./pullRecord");
+function relToRoot(p) {
+    try {
+        return path_1.default.relative(ConfigManager.getRootDir(), p) || ".";
+    }
+    catch (e) {
+        return p;
+    }
+}
+function describeRecord(rec, dryRun) {
+    const lines = [];
+    const verb = dryRun ? "would write" : "wrote";
+    lines.push(chalk_1.default.bold(rec.table) + " " + rec.sysId + "  →  " + chalk_1.default.cyan(relToRoot(rec.recordDir) + path_1.default.sep) +
+        chalk_1.default.dim("  [" + rec.scope + "]"));
+    for (const f of rec.files) {
+        const mark = f.action === "write" ? chalk_1.default.green("+") : chalk_1.default.dim("=");
+        const note = f.action === "write" ? verb : "unchanged";
+        lines.push("  " + mark + " " + path_1.default.basename(f.path) + chalk_1.default.dim("  (" + note + ")"));
+    }
+    const manifestNote = rec.manifestAction === "add" ? "add" : rec.manifestAction === "update" ? "update" : "unchanged";
+    lines.push("  " + (rec.manifestAction === "unchanged" ? chalk_1.default.dim("=") : chalk_1.default.green("~")) +
+        " manifest key " + JSON.stringify(rec.key) + chalk_1.default.dim("  (" + manifestNote + ")"));
+    for (const w of rec.warnings)
+        lines.push("  " + chalk_1.default.yellow("!") + " " + w);
+    return lines;
+}
+function report(plan, dryRun) {
+    for (const rec of plan.records) {
+        for (const line of describeRecord(rec, dryRun))
+            Logger_1.logger.info(line);
+    }
+    for (const m of plan.manifests) {
+        const touched = m.records.filter((r) => r.manifestAction !== "unchanged").length;
+        if (touched === 0)
+            continue;
+        Logger_1.logger.info((dryRun ? "would splice " : "spliced ") + touched + " entr" + (touched === 1 ? "y" : "ies") +
+            " into " + chalk_1.default.cyan(relToRoot(m.manifestPath)) + (m.existed ? "" : chalk_1.default.dim("  (new file)")));
+    }
+    for (const w of plan.warnings)
+        Logger_1.logger.warn(w);
+}
+/**
+ * Turn the CLI arguments into pull targets. Positional sys_ids and `--sys-ids`
+ * compose; `--from-update-set` expands to the set's per-record captures (and
+ * composes with an explicit table + sys_ids too).
+ */
+async function collectTargets(args) {
+    const targets = [];
+    let skipped = [];
+    const ids = (0, pullRecord_1.normalizeSysIds)([]
+        .concat(Array.isArray(args.sysId) ? args.sysId : [args.sysId])
+        .concat(Array.isArray(args.sysIds) ? args.sysIds : [args.sysIds])
+        .concat(Array.isArray(args["sys-ids"]) ? args["sys-ids"] : [args["sys-ids"]]));
+    if (args.table) {
+        const table = (0, pullRecord_1.assertTableName)(args.table);
+        if (ids.length === 0 && !args.fromUpdateSet) {
+            throw new Error("dove pull " + table + ": give at least one sys_id (positional, or --sys-ids a,b,c), " +
+                "or use --from-update-set <sys_id>. A bare 'dove pull' is the scope-wide refresh.");
+        }
+        for (const sysId of ids)
+            targets.push({ table, sysId });
+    }
+    else if (ids.length > 0) {
+        throw new Error("dove pull: a table name is required before the sys_id(s).");
+    }
+    if (args.fromUpdateSet) {
+        const fromSet = await (0, pullRecord_1.targetsFromUpdateSet)(String(args.fromUpdateSet));
+        for (const t of fromSet.targets)
+            targets.push(t);
+        skipped = fromSet.skipped;
+    }
+    return { targets, skipped };
+}
+async function pullRecordCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    try {
+        if (args.t !== undefined && !args.table) {
+            throw new Error("dove pull has no -t/--table flag. For a table-narrowed scope refresh use " +
+                "'dove refresh -t <table>'; for one record use 'dove pull <table> <sys_id>'.");
+        }
+        const dryRun = !!args.dryRun;
+        const { targets, skipped } = await collectTargets(args);
+        for (const s of skipped)
+            Logger_1.logger.warn("skipped " + s);
+        if (targets.length === 0) {
+            throw new Error("Nothing to pull: no per-record targets resolved.");
+        }
+        FileLogger_1.fileLogger.debug("pull: " + targets.length + " target(s), scope=" + (args.scope || "auto") +
+            ", force=" + !!args.force + ", dryRun=" + dryRun);
+        const plan = await (0, pullRecord_1.planPull)(targets, { scope: args.scope, force: !!args.force });
+        if (dryRun) {
+            Logger_1.logger.info(chalk_1.default.bold("Dry run — nothing written."));
+            report(plan, true);
+            return;
+        }
+        const result = await (0, pullRecord_1.applyPull)(plan);
+        report(plan, false);
+        Logger_1.logger.success("Pulled " + plan.records.length + " record(s): " + result.filesWritten + " file(s) written, " +
+            result.filesUnchanged + " unchanged, " + result.manifestsWritten.length + " manifest(s) updated.");
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        Logger_1.logger.error(message);
+        FileLogger_1.fileLogger.error("pull failed: " + message);
+        process.exitCode = 1;
+    }
+}

package/dist/reconcileCommand.js

@@ -53,6 +53,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCreates = applyCreates;
 exports.reconcileCommand = reconcileCommand;
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
@@ -338,6 +339,7 @@ async function buildCreateFields(scope, change) {
     }
     return fields;
 }
+// Exported for tests.
 async function applyCreates(scope, creates, updateSetSysId) {
     if (creates.length === 0) {
         return [];

package/dist/snClient.js

@@ -334,14 +334,28 @@ const snClient = (baseURL, username, password, apiKey) => {
         const endpoint = `api/now/table/${table}/${recordId}`;
         return client.patch(endpoint, fields);
     };
-    const getScopeId = (scopeName) => {
+    // Resolve a scope name to its sys_scope sys_id. `scope=<name>` is not unique
+    // on every instance: `scope=global` also matches sys_app rows (their scope
+    // column is "global"), so the real Global scope is addressed by its fixed
+    // sys_id, and any other ambiguous name is refused rather than guessed.
+    const getScopeId = async (scopeName) => {
         const endpoint = "api/now/table/sys_scope";
-        return client.get(endpoint, {
+        const query = scopeName === "global" ? "sys_id=global" : `scope=${scopeName}`;
+        const resp = await client.get(endpoint, {
             params: {
-                sysparm_query: `scope=${scopeName}`,
+                sysparm_query: query,
                 sysparm_fields: "sys_id",
             },
         });
+        const rows = resp && resp.data && Array.isArray(resp.data.result)
+            ? resp.data.result
+            : [];
+        if (rows.length > 1) {
+            const ids = rows.map((row) => (row && row.sys_id) || "?").join(", ");
+            throw new Error(`Scope "${scopeName}" is ambiguous: ${rows.length} sys_scope rows match ` +
+                `(${ids}). Refusing to guess which one owns the change.`);
+        }
+        return resp;
     };
     const getScopeById = (scopeSysId) => {
         const endpoint = "api/now/table/sys_scope";
@@ -366,6 +380,54 @@ const snClient = (baseURL, username, password, apiKey) => {
             },
         });
     };
+    /**
+     * In-progress update sets with exactly this name in one application, so a
+     * create can refuse a duplicate (a retry after a timeout would otherwise
+     * leave two same-named sets, and activate-by-name picks either). A `^` in
+     * the name is escaped as `^^` so it cannot split the encoded query.
+     */
+    const getInProgressUpdateSetsByName = (updateSetName, applicationSysId) => {
+        const endpoint = "api/now/table/sys_update_set";
+        const safeName = String(updateSetName).replace(/\^/g, "^^");
+        return client.get(endpoint, {
+            params: {
+                sysparm_query: `name=${safeName}^application=${applicationSysId}` +
+                    "^state=in progress",
+                sysparm_fields: "sys_id,name,application",
+            },
+        });
+    };
+    /**
+     * Reads ONE record by sys_id, selecting only its class and owning scope, so a
+     * per-record pull can resolve (and refuse) the target scope before it fetches
+     * any content. Plain Table API read — no Dovetail server op involved.
+     */
+    const getRecordScope = (table, sysId) => {
+        const endpoint = "api/now/table/" + encodeURIComponent(table) + "/" + encodeURIComponent(sysId);
+        return client.get(endpoint, {
+            params: {
+                sysparm_fields: "sys_id,sys_class_name,sys_scope,sys_scope.scope",
+                sysparm_display_value: "false",
+            },
+        });
+    };
+    /**
+     * One page of a update set's customer updates (`sys_update_xml`), ordered by
+     * name so paging is stable. The caller pages with offset/limit; the instance
+     * caps a single page at 1000 rows.
+     */
+    const getUpdateSetMembers = (updateSetSysId, offset, limit) => {
+        const endpoint = "api/now/table/sys_update_xml";
+        return client.get(endpoint, {
+            params: {
+                sysparm_query: "update_set=" + updateSetSysId + "^ORDERBYname",
+                sysparm_fields: "sys_id,name,action,target_name,type",
+                sysparm_display_value: "false",
+                sysparm_limit: limit,
+                sysparm_offset: offset,
+            },
+        });
+    };
     const getUserSysId = (userName = process.env.SN_USER) => {
         const endpoint = "api/now/table/sys_user";
         return client.get(endpoint, {
@@ -527,6 +589,16 @@ const snClient = (baseURL, username, password, apiKey) => {
                 "or in Studio then run `dove refresh -s <scope>` to materialise " +
                 "the new records locally."));
         }
+        // Guard: the generic createRecord op never sets `application`, so an
+        // update set inserted through it lands in the session app (and a
+        // name-only read-back still passes). Update sets must go through the
+        // scope-correct createUpdateSet op.
+        if (params && params.table === "sys_update_set") {
+            return Promise.reject(new Error("Refusing to insert sys_update_set via createRecord: the generic " +
+                "createRecord op does not set the update set's application, so it " +
+                "would land in the session app. Use `dove createUpdateSet --name " +
+                "<name> --scope <scope>` instead."));
+        }
         return _callDovetailApi("createRecord", (endpoint) => client.post(endpoint, params));
     };
     const deleteRecord = (params) => {
@@ -538,6 +610,9 @@ const snClient = (baseURL, username, password, apiKey) => {
         getScopeId,
         getScopeById,
         getUpdateSetById,
+        getInProgressUpdateSetsByName,
+        getRecordScope,
+        getUpdateSetMembers,
         getUserSysId,
         getCurrentAppUserPrefSysId,
         updateCurrentAppUserPref,

package/dist/tests/claudeSession.test.js

@@ -4,6 +4,28 @@
 // explicit env object is passed so the real process.env never leaks in.
 Object.defineProperty(exports, "__esModule", { value: true });
 const claudeSession_1 = require("../claudeSession");
+describe("isClaudeCodeToolShell (hard-block signal)", function () {
+    it("is true only when CLAUDECODE has a value", function () {
+        expect((0, claudeSession_1.isClaudeCodeToolShell)({ CLAUDECODE: "1" })).toBe(true);
+        expect((0, claudeSession_1.isClaudeCodeToolShell)({ CLAUDECODE: " " })).toBe(false);
+        expect((0, claudeSession_1.isClaudeCodeToolShell)({})).toBe(false);
+    });
+    it("ignores CLAUDE_CODE_* config variables a human may have in their profile", function () {
+        expect((0, claudeSession_1.isClaudeCodeToolShell)({ CLAUDE_CODE_USE_BEDROCK: "1" })).toBe(false);
+        expect((0, claudeSession_1.isClaudeCodeSession)({ CLAUDE_CODE_USE_BEDROCK: "1" })).toBe(true);
+    });
+});
+describe("isWatchInClaudeAllowed", function () {
+    it("accepts exactly 1", function () {
+        expect((0, claudeSession_1.isWatchInClaudeAllowed)({ DOVE_ALLOW_WATCH_IN_CLAUDE: "1" })).toBe(true);
+    });
+    it("rejects unset, empty, and other truthy-looking values", function () {
+        expect((0, claudeSession_1.isWatchInClaudeAllowed)({})).toBe(false);
+        expect((0, claudeSession_1.isWatchInClaudeAllowed)({ DOVE_ALLOW_WATCH_IN_CLAUDE: "" })).toBe(false);
+        expect((0, claudeSession_1.isWatchInClaudeAllowed)({ DOVE_ALLOW_WATCH_IN_CLAUDE: "true" })).toBe(false);
+        expect((0, claudeSession_1.isWatchInClaudeAllowed)({ DOVE_ALLOW_WATCH_IN_CLAUDE: "0" })).toBe(false);
+    });
+});
 describe("isClaudeCodeSession", function () {
     it("returns false for an empty environment", function () {
         expect((0, claudeSession_1.isClaudeCodeSession)({})).toBe(false);

package/dist/tests/commanderStrict.test.js

@@ -39,6 +39,7 @@ jest.mock("../schemaCommand", () => ({
 jest.mock("../claudeCommand", () => ({ initClaudeCommand: jest.fn() }));
 jest.mock("../createRecordCommand", () => ({ createRecordCommand: jest.fn() }));
 jest.mock("../deleteRecordCommand", () => ({ deleteRecordCommand: jest.fn() }));
+jest.mock("../pullRecordCommand", () => ({ pullRecordCommand: jest.fn() }));
 jest.mock("../reconcileCommand", () => ({ reconcileCommand: jest.fn() }));
 jest.mock("../migrateCommand", () => ({ migrateCommand: jest.fn() }));
 jest.mock("../loginCommand", () => ({ loginCommand: jest.fn() }));
@@ -58,6 +59,7 @@ jest.mock("../clickupCommands", () => ({
 const yargs_1 = __importDefault(require("yargs/yargs"));
 const commander_1 = require("../commander");
 const commands_1 = require("../commands");
+const pullRecordCommand_1 = require("../pullRecordCommand");
 /**
  * @description Runs a fake `dove` invocation through a fresh, non-exiting parser.
  * @param {string[]} args - Argv as the user would type it, minus the binary name.
@@ -82,12 +84,17 @@ async function run(args) {
 }
 beforeEach(function () {
     jest.clearAllMocks();
+    process.exitCode = undefined;
+});
+afterEach(function () {
+    process.exitCode = undefined;
 });
 describe("dove pull", function () {
     it("routes `pull` to the refresh command", async function () {
         const { error } = await run(["pull"]);
         expect(error).toBeUndefined();
         expect(commands_1.refreshCommand).toHaveBeenCalledTimes(1);
+        expect(process.exitCode).toBeUndefined();
     });
     it("still routes the canonical `refresh` and its `r` alias", async function () {
         await run(["refresh"]);
@@ -101,6 +108,67 @@ describe("dove pull", function () {
         expect(argv.scope).toBe("x_cadso_core");
         expect(argv.force).toBe(true);
         expect(commands_1.refreshCommand).toHaveBeenCalledTimes(1);
+        expect(pullRecordCommand_1.pullRecordCommand).not.toHaveBeenCalled();
+    });
+    it("re-maps a bare `pull -t <table>` to refresh --table (the old spelling keeps working)", async function () {
+        const { error } = await run(["pull", "-t", "sys_script_include", "--metadata-only"]);
+        expect(error).toBeUndefined();
+        expect(commands_1.refreshCommand).toHaveBeenCalledTimes(1);
+        const passed = commands_1.refreshCommand.mock.calls[0][0];
+        expect(passed.table).toBe("sys_script_include");
+        expect(passed.metadataOnly).toBe(true);
+        expect(pullRecordCommand_1.pullRecordCommand).not.toHaveBeenCalled();
+    });
+    it("routes `pull <table> <sysId...>` to the per-record pull, not refresh", async function () {
+        const { error, argv } = await run([
+            "pull", "sys_security_acl", "94243ee5c3f78f10d4ddf1db050131a6", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1",
+            "--scope", "x_cadso_journey", "--dry-run",
+        ]);
+        expect(error).toBeUndefined();
+        expect(argv.table).toBe("sys_security_acl");
+        expect(argv.sysId).toEqual(["94243ee5c3f78f10d4ddf1db050131a6", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1"]);
+        expect(argv.dryRun).toBe(true);
+        expect(pullRecordCommand_1.pullRecordCommand).toHaveBeenCalledTimes(1);
+        expect(commands_1.refreshCommand).not.toHaveBeenCalled();
+    });
+    it("keeps --sys-ids distinct from the positional list", async function () {
+        const { error, argv } = await run([
+            "pull", "sys_security_acl", "94243ee5c3f78f10d4ddf1db050131a6",
+            "--sys-ids", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1,bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb2",
+        ]);
+        expect(error).toBeUndefined();
+        expect(argv.sysId).toEqual(["94243ee5c3f78f10d4ddf1db050131a6"]);
+        expect(argv.sysIds).toBe("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1,bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb2");
+        expect(pullRecordCommand_1.pullRecordCommand).toHaveBeenCalledTimes(1);
+    });
+    it("refuses a bare `pull --dry-run` instead of running a real full refresh", async function () {
+        const { error } = await run(["pull", "--dry-run"]);
+        expect(error).toBeDefined();
+        expect(String(error)).toMatch(/--dry-run needs a table/);
+        expect(String(error)).toMatch(/full refresh/);
+        expect(process.exitCode).toBe(1);
+        expect(commands_1.refreshCommand).not.toHaveBeenCalled();
+        expect(pullRecordCommand_1.pullRecordCommand).not.toHaveBeenCalled();
+    });
+    it("refuses `pull --sys-ids <id>` with no table instead of running a full refresh", async function () {
+        const { error } = await run(["pull", "--sys-ids", "94243ee5c3f78f10d4ddf1db050131a6"]);
+        expect(error).toBeDefined();
+        expect(String(error)).toMatch(/needs a table/);
+        expect(String(error)).toMatch(/full refresh/);
+        expect(commands_1.refreshCommand).not.toHaveBeenCalled();
+        expect(pullRecordCommand_1.pullRecordCommand).not.toHaveBeenCalled();
+    });
+    it("refuses a bare `pull -t <table> --dry-run` (refresh has no dry run)", async function () {
+        const { error } = await run(["pull", "-t", "sys_script_include", "--dry-run"]);
+        expect(error).toBeDefined();
+        expect(commands_1.refreshCommand).not.toHaveBeenCalled();
+    });
+    it("routes `pull --from-update-set` (no table) to the per-record pull", async function () {
+        const { error, argv } = await run(["pull", "--from-update-set", "dddddddddddddddddddddddddddddddd"]);
+        expect(error).toBeUndefined();
+        expect(argv.fromUpdateSet).toBe("dddddddddddddddddddddddddddddddd");
+        expect(pullRecordCommand_1.pullRecordCommand).toHaveBeenCalledTimes(1);
+        expect(commands_1.refreshCommand).not.toHaveBeenCalled();
     });
 });
 describe("unknown commands", function () {

package/dist/tests/createRecordUpdateSet.test.js

@@ -66,6 +66,7 @@ var mockClient = {
     getScopeId: jest.fn(),
     getScopeById: jest.fn(),
     getUpdateSetById: jest.fn(),
+    getInProgressUpdateSetsByName: jest.fn(),
     createUpdateSet: jest.fn(),
     createRecord: jest.fn(),
 };
@@ -120,6 +121,9 @@ describe("dove create sys_update_set (#231)", function () {
             }
             return axiosResult([]);
         });
+        mockClient.getInProgressUpdateSetsByName.mockImplementation(function () {
+            return axiosResult([]);
+        });
         mockClient.createUpdateSet.mockImplementation(function (name, scopeSysId) {
             return axiosResult({ sys_id: SET_SYS_ID, name: name, application: scopeSysId });
         });
@@ -159,6 +163,42 @@ describe("dove create sys_update_set (#231)", function () {
         expect(success[0].msg).toContain(SET_SYS_ID);
         expect(success[0].msg).toContain(REQUESTED_SCOPE);
     });
+    it("prints an activation hint keyed on the new set's sys_id, not its name", async function () {
+        mockClient.getUpdateSetById.mockReturnValue(axiosResult([{ sys_id: SET_SYS_ID, application: { value: REQUESTED_SCOPE_SYS_ID } }]));
+        await (0, createRecordCommand_1.createRecordCommand)({
+            table: "sys_update_set",
+            name: "Journey - Fix 231",
+            scope: REQUESTED_SCOPE,
+            ci: true,
+            logLevel: "info",
+        });
+        expect(mockClient.getInProgressUpdateSetsByName).toHaveBeenCalledWith("Journey - Fix 231", REQUESTED_SCOPE_SYS_ID);
+        var hint = logMessages.filter(function (m) {
+            return m.level === "info" && m.msg.indexOf("switchUpdateSet") !== -1;
+        });
+        expect(hint).toHaveLength(1);
+        expect(hint[0].msg).toContain("--sysId " + SET_SYS_ID);
+        expect(hint[0].msg).toContain("-s " + REQUESTED_SCOPE);
+        expect(hint[0].msg).not.toContain("--name");
+    });
+    it("refuses (exit 1, no op call) when an in-progress set with the same name already exists in the scope", async function () {
+        mockClient.getInProgressUpdateSetsByName.mockImplementation(function () {
+            return axiosResult([{ sys_id: "existingSetSysId000000000000000cd", name: "Journey - Fix 231" }]);
+        });
+        await expect((0, createRecordCommand_1.createRecordCommand)({
+            table: "sys_update_set",
+            name: "Journey - Fix 231",
+            scope: REQUESTED_SCOPE,
+            ci: true,
+            logLevel: "info",
+        })).rejects.toBeInstanceOf(ExitSignal);
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        expect(mockClient.createUpdateSet).not.toHaveBeenCalled();
+        expect(mockClient.createRecord).not.toHaveBeenCalled();
+        expect(logMessages.filter(function (m) { return m.level === "success"; })).toHaveLength(0);
+        expect(errorText()).toContain("already exists");
+        expect(errorText()).toContain("existingSetSysId000000000000000cd");
+    });
     it("fails loudly (exit 1, no success) when the created set's application is not the requested scope", async function () {
         // The op "succeeded" but the set landed in the session's current app.
         mockClient.createUpdateSet.mockImplementation(function (name) {

package/dist/tests/dovetailUtilsMSTableOptions.test.js

@@ -56,6 +56,7 @@ function makeGlideRecord(rows, captured, validFields) {
             return validFields === null ? true : validFields.indexOf(field) !== -1;
         };
         this.query = function () {
+            captured.queryCalls += 1;
             i = -1;
         };
         this.next = function () {
@@ -85,7 +86,11 @@ function makeGlideRecord(rows, captured, validFields) {
 function loadUtils(opts) {
     const rows = opts.rows || [];
     const warnings = [];
-    const captured = { encodedQueries: [], fieldQueries: [] };
+    const captured = {
+        encodedQueries: [],
+        fieldQueries: [],
+        queryCalls: 0,
+    };
     const metadataClasses = opts.metadataClasses || [];
     const sandbox = {
         Class: {
@@ -185,7 +190,13 @@ describe("DovetailUtilsMS.buildTableMap — scopeQuery", () => {
         expect(scopeFilters).toHaveLength(0);
     });
     it("renders {scopeId} as the scope sys_id", () => {
-        const out = buildChoices({ scopeQuery: "sys_package={scopeId}" });
+        const out = buildChoices({ scopeQuery: "sys_package={scopeId}" }, [
+            "name",
+            "element",
+            "value",
+            "label",
+            "sys_package",
+        ]);
         expect(out.captured.encodedQueries).toContain("sys_package=5e9f5f8b87420250369f33373cbb3559");
     });
     it("keeps the sys_scope filter when no scopeQuery is set (existing behaviour)", () => {
@@ -229,6 +240,102 @@ describe("DovetailUtilsMS.buildTableMap — scopeQuery", () => {
         expect(out.captured.encodedQueries).toHaveLength(0);
     });
 });
+describe("DovetailUtilsMS.buildTableMap — scopeQuery fails closed", () => {
+    // ServiceNow drops an encoded-query term on an unknown column, so an unchecked
+    // scopeQuery typo would return the WHOLE table (sys_choice: >200k rows) for every
+    // scope. buildTableMap must refuse such a query and never call query().
+    function expectRefused(out, reason) {
+        expect(out.captured.queryCalls).toBe(0);
+        expect(out.captured.encodedQueries).toHaveLength(0);
+        expect(Object.keys(out.records)).toHaveLength(0);
+        expect(out.warnings).toHaveLength(1);
+        expect(out.warnings[0]).toContain("sys_choice");
+        expect(out.warnings[0]).toContain("scopeQuery");
+        expect(out.warnings[0]).toMatch(reason);
+    }
+    // The fixture's three "Failed" labels also raise duplicate-name warnings; only
+    // scopeQuery refusals matter to the accept-path assertions.
+    function scopeQueryWarnings(warnings) {
+        return warnings.filter(function (w) {
+            return w.indexOf("scopeQuery") !== -1;
+        });
+    }
+    it("refuses a scopeQuery whose field does not exist on the table (typo)", () => {
+        const out = buildChoices({ scopeQuery: "nmeSTARTSWITH{scope}_" });
+        expectRefused(out, /nme/);
+    });
+    it("refuses a scopeQuery with no {scope}/{scopeId} token", () => {
+        const out = buildChoices({ scopeQuery: "active=true" }, null);
+        expectRefused(out, /\{scope\}/);
+    });
+    it("refuses a scopeQuery containing ^NQ", () => {
+        const out = buildChoices({
+            scopeQuery: "nameSTARTSWITH{scope}_^NQelement=state",
+        });
+        expectRefused(out, /\^NQ/);
+    });
+    it("verifies every ^OR term, not just the first", () => {
+        const out = buildChoices({
+            scopeQuery: "nameSTARTSWITH{scope}_^ORelmentSTARTSWITH{scope}_",
+        });
+        expectRefused(out, /elment/);
+    });
+    it("refuses a dot-walked field it cannot verify", () => {
+        const out = buildChoices({ scopeQuery: "name.sys_scope={scopeId}" }, null);
+        expectRefused(out, /name\.sys_scope/);
+    });
+    it("refuses a term with no operator", () => {
+        const out = buildChoices({ scopeQuery: "nameSTARTSWITH{scope}_^element" });
+        expectRefused(out, /element/);
+    });
+    it("refuses an empty term (^^)", () => {
+        const out = buildChoices({
+            scopeQuery: "nameSTARTSWITH{scope}_^^element=x",
+        });
+        expectRefused(out, /empty/);
+    });
+    it("refuses when the scope token would render empty", () => {
+        const loaded = loadUtils({
+            rows: CHOICE_ROWS,
+            validFields: ["name", "element", "value", "label"],
+        });
+        const result = loaded.utils.buildTableMap({
+            tableName: "sys_choice",
+            scopeId: null,
+            scopeName: "",
+            getContents: false,
+            includes: { sys_choice: { label: { type: "txt" } } },
+            excludes: {},
+            tableOptions: { scopeQuery: "nameSTARTSWITH{scope}_" },
+        });
+        expect(loaded.captured.queryCalls).toBe(0);
+        expect(Object.keys(result.records)).toHaveLength(0);
+        expect(loaded.warnings[0]).toMatch(/empty/);
+    });
+    it("accepts a valid ^OR template unchanged and runs the query", () => {
+        const out = buildChoices({
+            scopeQuery: "nameSTARTSWITH{scope}_^ORelementSTARTSWITH{scope}_",
+        });
+        expect(out.captured.queryCalls).toBe(1);
+        expect(out.captured.encodedQueries).toEqual([
+            "nameSTARTSWITHx_cadso_automate_^ORelementSTARTSWITHx_cadso_automate_",
+        ]);
+        expect(scopeQueryWarnings(out.warnings)).toHaveLength(0);
+        expect(Object.keys(out.records).length).toBeGreaterThan(0);
+    });
+    it("accepts symbol and word operators (!=, ISNOTEMPTY, IN, ORDERBY)", () => {
+        const out = buildChoices({
+            scopeQuery: "nameSTARTSWITH{scope}_^element!=x^valueISNOTEMPTY^labelINa,b^ORDERBYname",
+        });
+        expect(out.captured.queryCalls).toBe(1);
+        expect(scopeQueryWarnings(out.warnings)).toHaveLength(0);
+    });
+    it("leaves tables without a scopeQuery on the sys_scope path (no validation)", () => {
+        const out = buildChoices({}, []);
+        expect(out.captured.queryCalls).toBe(1);
+        expect(scopeQueryWarnings(out.warnings)).toHaveLength(0);
+    });
+});
 describe("DovetailUtilsMS.generateRecordName — nameTemplate", () => {
     it("names sys_choice folders {name}.{element}.{value} so same-label rows never collide", () => {
         const out = buildChoices({ nameTemplate: "{name}.{element}.{value}" });