@tenonhq/dovetail-core 0.0.122 → 0.0.123

package/README.md

@@ -35,6 +35,14 @@ npx dove migrate       # migrate a Sincronia project to Dovetail (dry-run by def
 
 See [`UPDATE_SET_COMMANDS.md`](UPDATE_SET_COMMANDS.md) for the full update-set CLI surface.
 
+### `dove create sys_update_set`
+
+`npx dove create <table>` inserts through the generic `createRecord` endpoint — except for `sys_update_set`. A plain insert lets ServiceNow default the set's `application` to the API session's current app, so `--scope` was silently ignored and the set landed in whatever scope the session was in (TenonHQ/Dovetail#231). Update sets therefore route through the atomic, scope-correct `createUpdateSet` server op (`POST /api/cadso/dovetail_core/createUpdateSet`) and the created set is read back: if its `application` does not match the requested scope the command exits non-zero, naming the requested vs. actual scope and the set's sys_id, so a mis-scoped set is never reported as success.
+
+- `--scope` decides the application. It is **required** with `--ci`; interactively it is confirmed in the summary.
+- Only `name` and `description` map onto the op; other `--field` values are ignored with a warning.
+- The set is created, not activated — use `npx dove switchUpdateSet --name "<name>" -s <scope>` (or `npx dove createUpdateSet`, which creates and activates in one step).
+
 ## Plugins
 
 Dovetail's build pipeline is plugin-driven. Each plugin is an npm package implementing `run(context, content, options) => Promise<PluginResults>`. Shipped plugins live in sibling packages (`@tenonhq/dovetail-typescript-plugin`, `-babel-plugin`, `-webpack-plugin`, `-sass-plugin`, `-eslint-plugin`, `-prettier-plugin`, `-babel-preset-servicenow`, `-babel-plugin-remove-modules`).

package/dist/commander.js

@@ -214,7 +214,7 @@ function configureCli(cli) {
         await (0, commands_1.buildCommand)(args);
     })
         .command("deploy", "Deploy local build files to the scoped application", sharedOptions, commands_1.deployCommand)
-        .command("create <table>", "Create a new record on the ServiceNow instance", (cmdArgs) => {
+        .command("create <table>", "Create a new record on the ServiceNow instance (sys_update_set goes through the scope-correct createUpdateSet op; --scope decides its application)", (cmdArgs) => {
         cmdArgs.positional("table", {
             describe: "ServiceNow table name (e.g., sys_script_include)",
             type: "string",
@@ -229,7 +229,7 @@ function configureCli(cli) {
             scope: {
                 alias: "s",
                 type: "string",
-                describe: "Target scope (e.g., x_cadso_core)",
+                describe: "Target scope (e.g., x_cadso_core). For sys_update_set this decides the set's application and is required with --ci",
             },
             from: {
                 alias: "f",

package/dist/createRecordCommand.js

@@ -36,6 +36,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateSetScopeMismatchError = exports.UPDATE_SET_TABLE = void 0;
+exports.createUpdateSetRecord = createUpdateSetRecord;
 exports.createRecordCommand = createRecordCommand;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -48,6 +50,55 @@ const commands_1 = require("./commands");
 const ConfigManager = __importStar(require("./config"));
 const AppUtils = __importStar(require("./appUtils"));
 const projectFiles_1 = require("./projectFiles");
+/**
+ * Table whose rows must NOT go through the generic record insert. A plain
+ * insert lets ServiceNow default `application` to the API session's current
+ * app (gs.getCurrentApplicationId()), so `--scope` was silently ignored and
+ * the set landed in whatever scope the session happened to be in
+ * (TenonHQ/Dovetail#231). Rows for this table route through the atomic
+ * `createUpdateSet` server op instead.
+ */
+exports.UPDATE_SET_TABLE = "sys_update_set";
+/** Fields `dove create` can map onto the createUpdateSet server op. */
+const UPDATE_SET_OP_FIELDS = ["name", "description"];
+/** Scope names are identifiers (`x_cadso_core`, `global`) — nothing else. */
+const SCOPE_NAME_PATTERN = /^[A-Za-z0-9_]+$/;
+/**
+ * Raised when a created update set is readable but its `application` does
+ * not match the requested scope. Carries both sides so callers can print an
+ * actionable message and exit non-zero instead of claiming success.
+ */
+class UpdateSetScopeMismatchError extends Error {
+    updateSetSysId;
+    requestedScope;
+    requestedScopeSysId;
+    actualScope;
+    actualScopeSysId;
+    constructor(details) {
+        super('Update set "' +
+            details.updateSetName +
+            '" (' +
+            details.updateSetSysId +
+            ") landed in scope " +
+            details.actualScope +
+            " (" +
+            details.actualScopeSysId +
+            ") but --scope " +
+            details.requestedScope +
+            " (" +
+            details.requestedScopeSysId +
+            ") was requested. The set is MIS-SCOPED: delete it on the instance " +
+            "before it collects captures, then confirm the Dovetail " +
+            "createUpdateSet REST op is installed on this instance and retry.");
+        this.name = "UpdateSetScopeMismatchError";
+        this.updateSetSysId = details.updateSetSysId;
+        this.requestedScope = details.requestedScope;
+        this.requestedScopeSysId = details.requestedScopeSysId;
+        this.actualScope = details.actualScope;
+        this.actualScopeSysId = details.actualScopeSysId;
+    }
+}
+exports.UpdateSetScopeMismatchError = UpdateSetScopeMismatchError;
 const getUpdateSetConfig = () => {
     const configPath = (0, projectFiles_1.getUpdateSetsConfigPath)();
     try {
@@ -155,6 +206,142 @@ async function resolveScope(args) {
     ]);
     return scopeAnswer.scope;
 }
+/**
+ * Normalizes a Table API reference field — a bare sys_id string, or the
+ * `{ value, link }` object the Table API returns without display values —
+ * to its sys_id. Returns undefined for anything else (missing, empty, wrong
+ * shape) so callers never compare against garbage.
+ */
+function referenceSysId(value) {
+    if (typeof value === "string") {
+        return value.trim() === "" ? undefined : value.trim();
+    }
+    if (value !== null && typeof value === "object") {
+        var inner = value.value;
+        if (typeof inner === "string" && inner.trim() !== "") {
+            return inner.trim();
+        }
+    }
+    return undefined;
+}
+/**
+ * Reads the created set back and returns its `application` sys_id. Falls
+ * back to the create response when the read-back fails or carries no
+ * application. Returns undefined when neither source can prove the scope.
+ */
+async function readBackApplication(client, updateSetSysId, createResponseApplication) {
+    try {
+        var rows = await (0, snClient_1.unwrapSNResponse)(client.getUpdateSetById(updateSetSysId));
+        if (Array.isArray(rows) && rows.length > 0) {
+            var fromReadBack = referenceSysId(rows[0].application);
+            if (fromReadBack) {
+                return fromReadBack;
+            }
+        }
+        FileLogger_1.fileLogger.warn("Update set read-back returned no application for " + updateSetSysId);
+    }
+    catch (readErr) {
+        FileLogger_1.fileLogger.warn("Update set read-back failed for " +
+            updateSetSysId +
+            ": " +
+            (readErr instanceof Error ? readErr.message : String(readErr)));
+    }
+    return referenceSysId(createResponseApplication);
+}
+/**
+ * Resolves a scope sys_id back to its name for error messages. Never throws —
+ * falls back to the sys_id itself so a lookup failure can't mask the
+ * mismatch we are about to report.
+ */
+async function scopeNameForSysId(client, scopeSysId) {
+    try {
+        var rows = await (0, snClient_1.unwrapSNResponse)(client.getScopeById(scopeSysId));
+        if (Array.isArray(rows) && rows.length > 0 && rows[0].scope) {
+            return rows[0].scope;
+        }
+    }
+    catch (e) {
+        // fall through to the sys_id
+    }
+    return scopeSysId;
+}
+/**
+ * Creates a `sys_update_set` through the scope-correct `createUpdateSet`
+ * server op and PROVES it landed in the requested scope. Throws on a
+ * mis-scoped or unverifiable set — the caller must never report success.
+ */
+async function createUpdateSetRecord(client, scope, fields) {
+    if (typeof scope !== "string" || !SCOPE_NAME_PATTERN.test(scope)) {
+        throw new Error("Invalid scope name " +
+            JSON.stringify(scope) +
+            ": expected an application scope such as x_cadso_core.");
+    }
+    var name = typeof fields.name === "string" ? fields.name.trim() : "";
+    if (name === "") {
+        throw new Error("Update set name is required.");
+    }
+    var description = typeof fields.description === "string" && fields.description.trim() !== ""
+        ? fields.description
+        : undefined;
+    var unsupported = Object.keys(fields).filter(function (key) {
+        return UPDATE_SET_OP_FIELDS.indexOf(key) === -1;
+    });
+    if (unsupported.length > 0) {
+        Logger_1.logger.warn("sys_update_set is created through the scope-correct createUpdateSet " +
+            "op, which accepts only " +
+            UPDATE_SET_OP_FIELDS.join(", ") +
+            ". Ignoring field(s): " +
+            unsupported.join(", "));
+    }
+    // Resolve the scope name to the application sys_id the op needs.
+    var scopeRows = await (0, snClient_1.unwrapSNResponse)(client.getScopeId(scope));
+    if (!Array.isArray(scopeRows) || scopeRows.length === 0) {
+        throw new Error('Scope "' + scope + '" not found on the instance.');
+    }
+    var scopeSysId = scopeRows[0].sys_id;
+    if (typeof scopeSysId !== "string" || scopeSysId.trim() === "") {
+        throw new Error('Scope "' + scope + '" resolved without a sys_id.');
+    }
+    FileLogger_1.fileLogger.debug("createUpdateSet op:", JSON.stringify({ name: name, scope: scope, application: scopeSysId }));
+    var created = await (0, snClient_1.unwrapSNResponse)(client.createUpdateSet(name, scopeSysId, description));
+    var createdSysId = created && typeof created.sys_id === "string" ? created.sys_id : "";
+    if (createdSysId === "") {
+        throw new Error("createUpdateSet returned no sys_id for " + name);
+    }
+    // Verify on the way out: the whole point of this path is that the set is
+    // in the requested scope, so prove it rather than trust the op.
+    var actualScopeSysId = await readBackApplication(client, createdSysId, created.application);
+    if (!actualScopeSysId) {
+        throw new Error('Update set "' +
+            name +
+            '" (' +
+            createdSysId +
+            ") was created but its application scope could not be verified " +
+            "(requested " +
+            scope +
+            " / " +
+            scopeSysId +
+            "). Inspect the set on the instance before using it.");
+    }
+    if (actualScopeSysId !== scopeSysId) {
+        var actualScope = await scopeNameForSysId(client, actualScopeSysId);
+        throw new UpdateSetScopeMismatchError({
+            updateSetName: name,
+            updateSetSysId: createdSysId,
+            requestedScope: scope,
+            requestedScopeSysId: scopeSysId,
+            actualScope: actualScope,
+            actualScopeSysId: actualScopeSysId,
+        });
+    }
+    var createdName = created.name;
+    return {
+        sysId: createdSysId,
+        name: typeof createdName === "string" && createdName !== "" ? createdName : name,
+        scope: scope,
+        scopeSysId: scopeSysId,
+    };
+}
 /**
  * Main create record command handler.
  */
@@ -167,7 +354,16 @@ async function createRecordCommand(args) {
             Logger_1.logger.error("Table name is required");
             process.exit(1);
         }
+        var isUpdateSet = table === exports.UPDATE_SET_TABLE;
         FileLogger_1.fileLogger.debug("Create record: table=" + table);
+        // An update set's application is decided by --scope alone. In CI there is
+        // no human to confirm a manifest-inferred scope, so require it explicitly
+        // rather than let an inherited scope mis-route every later capture.
+        if (isUpdateSet && typedArgs.ci && !typedArgs.scope) {
+            Logger_1.logger.error("--scope is required when creating sys_update_set in --ci mode: " +
+                "the scope decides the update set's application.");
+            process.exit(1);
+        }
         // 1. Build field values from all sources
         var fields = {};
         // Load from JSON file if provided
@@ -209,13 +405,17 @@ async function createRecordCommand(args) {
         // 3. Resolve scope
         var scope = await resolveScope(typedArgs);
         Logger_1.logger.info("Scope: " + chalk_1.default.cyan(scope));
-        // 4. Check update set configuration
-        var updateSetConfig = getUpdateSetConfig();
-        var updateSet = updateSetConfig[scope];
+        // 4. Check update set configuration. An update set is not itself captured
+        // in an update set, so skip the lookup for sys_update_set.
+        var updateSet;
         var updateSetSysId;
-        if (updateSet) {
-            Logger_1.logger.info("Update set: " + chalk_1.default.cyan(updateSet.name));
-            updateSetSysId = updateSet.sys_id;
+        if (!isUpdateSet) {
+            var updateSetConfig = getUpdateSetConfig();
+            updateSet = updateSetConfig[scope];
+            if (updateSet) {
+                Logger_1.logger.info("Update set: " + chalk_1.default.cyan(updateSet.name));
+                updateSetSysId = updateSet.sys_id;
+            }
         }
         // 5. Confirmation prompt
         if (!typedArgs.ci) {
@@ -224,6 +424,9 @@ async function createRecordCommand(args) {
             Logger_1.logger.info("  Table: " + chalk_1.default.cyan(table));
             Logger_1.logger.info("  Name: " + chalk_1.default.cyan(fields.name));
             Logger_1.logger.info("  Scope: " + chalk_1.default.cyan(scope));
+            if (isUpdateSet) {
+                Logger_1.logger.info("  Via: Dovetail createUpdateSet op (application = scope above)");
+            }
             if (updateSet) {
                 Logger_1.logger.info("  Update Set: " + chalk_1.default.cyan(updateSet.name));
             }
@@ -249,7 +452,29 @@ async function createRecordCommand(args) {
                 return;
             }
         }
-        // 6. Call the create endpoint
+        var client = (0, snClient_1.defaultClient)();
+        // 6a. sys_update_set: the scope-correct server op, verified on the way out.
+        if (isUpdateSet) {
+            Logger_1.logger.info("Creating update set via the Dovetail createUpdateSet op...");
+            var createdSet = await createUpdateSetRecord(client, scope, fields);
+            Logger_1.logger.success(chalk_1.default.green("Update set created: ") +
+                chalk_1.default.bold(createdSet.name) +
+                " (" +
+                createdSet.sysId +
+                ") in scope " +
+                chalk_1.default.cyan(createdSet.scope));
+            Logger_1.logger.info("Verified application = " +
+                createdSet.scope +
+                " (" +
+                createdSet.scopeSysId +
+                ").");
+            Logger_1.logger.info("Not activated. To route pushes to it: npx dove switchUpdateSet --name " +
+                JSON.stringify(createdSet.name) +
+                " -s " +
+                createdSet.scope);
+            return;
+        }
+        // 6b. Every other table: the generic create endpoint
         Logger_1.logger.info("Creating record...");
         FileLogger_1.fileLogger.debug("Create request:", JSON.stringify({
             table: table,
@@ -257,7 +482,6 @@ async function createRecordCommand(args) {
             scope: scope,
             update_set_sys_id: updateSetSysId,
         }));
-        var client = (0, snClient_1.defaultClient)();
         var createResponse = await client.createRecord({
             table: table,
             fields: fields,

package/dist/snClient.js

@@ -352,6 +352,20 @@ const snClient = (baseURL, username, password, apiKey) => {
             },
         });
     };
+    /**
+     * Reads one update set back by sys_id, selecting only `application`, so a
+     * caller can PROVE which application a freshly created set landed in. The
+     * Table API returns the reference as `{ value, link }` (no display value).
+     */
+    const getUpdateSetById = (updateSetSysId) => {
+        const endpoint = "api/now/table/sys_update_set";
+        return client.get(endpoint, {
+            params: {
+                sysparm_query: `sys_id=${updateSetSysId}`,
+                sysparm_fields: "sys_id,name,application",
+            },
+        });
+    };
     const getUserSysId = (userName = process.env.SN_USER) => {
         const endpoint = "api/now/table/sys_user";
         return client.get(endpoint, {
@@ -523,6 +537,7 @@ const snClient = (baseURL, username, password, apiKey) => {
         updateRecord,
         getScopeId,
         getScopeById,
+        getUpdateSetById,
         getUserSysId,
         getCurrentAppUserPrefSysId,
         updateCurrentAppUserPref,

package/dist/tests/createRecordUpdateSet.test.js

@@ -0,0 +1,276 @@
+"use strict";
+// Tests for `dove create sys_update_set` (TenonHQ/Dovetail#231).
+//
+// A generic record insert into sys_update_set lets ServiceNow default
+// `application` to the API session's current app, so `--scope` was silently
+// ignored. `dove create` must instead:
+//   1. route sys_update_set through snClient.createUpdateSet with the resolved
+//      scope's sys_id — and NOT call the generic createRecord;
+//   2. read the set back and exit non-zero, naming requested vs. actual scope
+//      and the set sys_id, when the application does not match;
+//   3. require --scope for sys_update_set in --ci mode;
+//   4. leave every other table on the generic createRecord path.
+//
+// Everything is mocked — no instance is contacted.
+Object.defineProperty(exports, "__esModule", { value: true });
+var logMessages = [];
+function pushLog(level) {
+    return jest.fn(function (msg) {
+        logMessages.push({ level: level, msg: String(msg) });
+    });
+}
+jest.mock("../Logger", function () {
+    return {
+        logger: {
+            setLogLevel: jest.fn(),
+            success: pushLog("success"),
+            info: pushLog("info"),
+            error: pushLog("error"),
+            warn: pushLog("warn"),
+            debug: jest.fn(),
+            getLogLevel: function () { return "info"; },
+        },
+    };
+});
+jest.mock("../FileLogger", function () {
+    return {
+        fileLogger: { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() },
+    };
+});
+jest.mock("../commands", function () {
+    return { setLogLevel: jest.fn() };
+});
+jest.mock("../config", function () {
+    return {
+        getManifest: jest.fn(function () { return undefined; }),
+        isMultiScopeManifest: jest.fn(function () { return false; }),
+        getConfig: jest.fn(function () { return {}; }),
+        getSourcePathForScope: jest.fn(function () { return "/virtual/src"; }),
+    };
+});
+var mockSyncManifest = jest.fn().mockResolvedValue(undefined);
+jest.mock("../appUtils", function () {
+    return { syncManifest: mockSyncManifest };
+});
+jest.mock("../projectFiles", function () {
+    return {
+        getUpdateSetsConfigPath: jest.fn(function () {
+            return "/nonexistent/dove-create-update-set-test/.dove-update-sets.json";
+        }),
+    };
+});
+jest.mock("inquirer", function () {
+    return { prompt: jest.fn() };
+});
+var mockClient = {
+    getScopeId: jest.fn(),
+    getScopeById: jest.fn(),
+    getUpdateSetById: jest.fn(),
+    createUpdateSet: jest.fn(),
+    createRecord: jest.fn(),
+};
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: jest.fn(function () { return mockClient; }),
+        // Mirror the real unwrapSNResponse: await the axios promise, return .data.result
+        unwrapSNResponse: jest.fn(async function (p) {
+            var resp = await p;
+            return resp.data.result;
+        }),
+    };
+});
+const createRecordCommand_1 = require("../createRecordCommand");
+function axiosResult(result) {
+    return Promise.resolve({ status: 200, data: { result: result } });
+}
+var REQUESTED_SCOPE = "x_cadso_journey";
+var REQUESTED_SCOPE_SYS_ID = "journeyScopeSysId0000000000000001";
+var SESSION_SCOPE = "x_cadso_core";
+var SESSION_SCOPE_SYS_ID = "coreScopeSysId00000000000000000002";
+var SET_SYS_ID = "updateSetSysId000000000000000000ab";
+class ExitSignal extends Error {
+    code;
+    constructor(code) {
+        super("process.exit(" + code + ")");
+        this.code = code;
+    }
+}
+describe("dove create sys_update_set (#231)", function () {
+    var exitSpy;
+    beforeEach(function () {
+        logMessages = [];
+        jest.clearAllMocks();
+        exitSpy = jest
+            .spyOn(process, "exit")
+            .mockImplementation(function (code) {
+            throw new ExitSignal(typeof code === "number" ? code : undefined);
+        });
+        mockClient.getScopeId.mockImplementation(function (scopeName) {
+            if (scopeName === REQUESTED_SCOPE) {
+                return axiosResult([{ sys_id: REQUESTED_SCOPE_SYS_ID }]);
+            }
+            return axiosResult([]);
+        });
+        mockClient.getScopeById.mockImplementation(function (sysId) {
+            if (sysId === SESSION_SCOPE_SYS_ID) {
+                return axiosResult([{ sys_id: SESSION_SCOPE_SYS_ID, scope: SESSION_SCOPE }]);
+            }
+            if (sysId === REQUESTED_SCOPE_SYS_ID) {
+                return axiosResult([{ sys_id: REQUESTED_SCOPE_SYS_ID, scope: REQUESTED_SCOPE }]);
+            }
+            return axiosResult([]);
+        });
+        mockClient.createUpdateSet.mockImplementation(function (name, scopeSysId) {
+            return axiosResult({ sys_id: SET_SYS_ID, name: name, application: scopeSysId });
+        });
+        mockClient.createRecord.mockResolvedValue({
+            status: 200,
+            data: { result: { sys_id: "genericSysId", table: "sys_script_include", name: "Generic" } },
+        });
+    });
+    afterEach(function () {
+        exitSpy.mockRestore();
+    });
+    function errorText() {
+        return logMessages
+            .filter(function (m) { return m.level === "error"; })
+            .map(function (m) { return m.msg; })
+            .join("\n");
+    }
+    it("routes through createUpdateSet with the requested scope and never calls the generic insert", async function () {
+        // Table API shape for a reference field without display values: { value, link }
+        mockClient.getUpdateSetById.mockReturnValue(axiosResult([{ sys_id: SET_SYS_ID, application: { value: REQUESTED_SCOPE_SYS_ID, link: "ref-link" } }]));
+        await (0, createRecordCommand_1.createRecordCommand)({
+            table: "sys_update_set",
+            name: "Journey - Fix 231",
+            scope: REQUESTED_SCOPE,
+            field: ["description=Issue 231 regression set"],
+            ci: true,
+            logLevel: "info",
+        });
+        expect(mockClient.createUpdateSet).toHaveBeenCalledTimes(1);
+        expect(mockClient.createUpdateSet).toHaveBeenCalledWith("Journey - Fix 231", REQUESTED_SCOPE_SYS_ID, "Issue 231 regression set");
+        expect(mockClient.createRecord).not.toHaveBeenCalled();
+        expect(mockClient.getUpdateSetById).toHaveBeenCalledWith(SET_SYS_ID);
+        expect(mockSyncManifest).not.toHaveBeenCalled();
+        expect(exitSpy).not.toHaveBeenCalled();
+        var success = logMessages.filter(function (m) { return m.level === "success"; });
+        expect(success.length).toBe(1);
+        expect(success[0].msg).toContain(SET_SYS_ID);
+        expect(success[0].msg).toContain(REQUESTED_SCOPE);
+    });
+    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) {
+            return axiosResult({ sys_id: SET_SYS_ID, name: name, application: SESSION_SCOPE_SYS_ID });
+        });
+        mockClient.getUpdateSetById.mockReturnValue(axiosResult([{ sys_id: SET_SYS_ID, application: { value: SESSION_SCOPE_SYS_ID } }]));
+        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.createRecord).not.toHaveBeenCalled();
+        expect(logMessages.filter(function (m) { return m.level === "success"; })).toHaveLength(0);
+        var errors = errorText();
+        expect(errors).toContain(SET_SYS_ID);
+        expect(errors).toContain(REQUESTED_SCOPE);
+        expect(errors).toContain(SESSION_SCOPE);
+        expect(errors).toContain(REQUESTED_SCOPE_SYS_ID);
+        expect(errors).toContain(SESSION_SCOPE_SYS_ID);
+    });
+    it("falls back to the op response when read-back is unavailable, and still catches a mismatch", async function () {
+        mockClient.createUpdateSet.mockImplementation(function (name) {
+            return axiosResult({ sys_id: SET_SYS_ID, name: name, application: SESSION_SCOPE_SYS_ID });
+        });
+        mockClient.getUpdateSetById.mockReturnValue(Promise.reject(new Error("read denied")));
+        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(errorText()).toContain(SESSION_SCOPE);
+        expect(errorText()).toContain(SET_SYS_ID);
+    });
+    it("refuses to verify-by-assumption: no application from any source is a failure, not a success", async function () {
+        mockClient.createUpdateSet.mockImplementation(function (name) {
+            return axiosResult({ sys_id: SET_SYS_ID, name: name });
+        });
+        mockClient.getUpdateSetById.mockReturnValue(axiosResult([{ sys_id: SET_SYS_ID }]));
+        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(errorText()).toContain("could not be verified");
+        expect(logMessages.filter(function (m) { return m.level === "success"; })).toHaveLength(0);
+    });
+    it("requires --scope for sys_update_set in --ci mode before touching the instance", async function () {
+        await expect((0, createRecordCommand_1.createRecordCommand)({
+            table: "sys_update_set",
+            name: "No Scope Set",
+            ci: true,
+            logLevel: "info",
+        })).rejects.toBeInstanceOf(ExitSignal);
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        expect(mockClient.createUpdateSet).not.toHaveBeenCalled();
+        expect(mockClient.createRecord).not.toHaveBeenCalled();
+        expect(mockClient.getScopeId).not.toHaveBeenCalled();
+        expect(errorText()).toContain("--scope");
+    });
+    it("errors when the requested scope does not exist on the instance", async function () {
+        await expect((0, createRecordCommand_1.createRecordCommand)({
+            table: "sys_update_set",
+            name: "Ghost Scope Set",
+            scope: "x_cadso_nope",
+            ci: true,
+            logLevel: "info",
+        })).rejects.toBeInstanceOf(ExitSignal);
+        expect(mockClient.createUpdateSet).not.toHaveBeenCalled();
+        expect(errorText()).toContain("x_cadso_nope");
+    });
+    it("keeps every other table on the generic createRecord path", async function () {
+        await (0, createRecordCommand_1.createRecordCommand)({
+            table: "sys_script_include",
+            name: "Generic",
+            scope: REQUESTED_SCOPE,
+            ci: true,
+            refresh: false,
+            logLevel: "info",
+        });
+        expect(mockClient.createRecord).toHaveBeenCalledTimes(1);
+        expect(mockClient.createRecord).toHaveBeenCalledWith({
+            table: "sys_script_include",
+            fields: { name: "Generic" },
+            scope: REQUESTED_SCOPE,
+            update_set_sys_id: undefined,
+        });
+        expect(mockClient.createUpdateSet).not.toHaveBeenCalled();
+        expect(mockClient.getScopeId).not.toHaveBeenCalled();
+        expect(exitSpy).not.toHaveBeenCalled();
+    });
+    it("exposes a typed mismatch error carrying both scopes", function () {
+        var err = new createRecordCommand_1.UpdateSetScopeMismatchError({
+            updateSetName: "n",
+            updateSetSysId: "s",
+            requestedScope: REQUESTED_SCOPE,
+            requestedScopeSysId: REQUESTED_SCOPE_SYS_ID,
+            actualScope: SESSION_SCOPE,
+            actualScopeSysId: SESSION_SCOPE_SYS_ID,
+        });
+        expect(err).toBeInstanceOf(Error);
+        expect(err.name).toBe("UpdateSetScopeMismatchError");
+        expect(err.requestedScope).toBe(REQUESTED_SCOPE);
+        expect(err.actualScope).toBe(SESSION_SCOPE);
+        expect(err.message).toContain("MIS-SCOPED");
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tenonhq/dovetail-core",
-  "version": "0.0.122",
+  "version": "0.0.123",
   "description": "Next-gen file syncer",
   "license": "GPL-3.0",
   "main": "./dist/index.js",