@tenonhq/dovetail-core 0.0.120 → 0.0.122

package/README.md

@@ -24,7 +24,7 @@ The full command surface is documented in the [root CLAUDE.md](../../CLAUDE.md#e
 Quick reference:
 
 ```bash
-npx dove watch         # multi-scope watch + dashboard
+npx dove watch         # HUMAN-ONLY local dev: multi-scope watch + dashboard (hidden from --help; stop before git checkout — see #155)
 npx dove push          # build + push current files
 npx dove refresh       # pull manifest + new files (aliases: pull, r)
 npx dove build         # local build only

package/dist/allScopesCommands.js

@@ -47,6 +47,7 @@ const AppUtils = __importStar(require("./appUtils"));
 const wizard_1 = require("./wizard");
 const snClient_1 = require("./snClient");
 const commands_1 = require("./commands");
+const claudeSession_1 = require("./claudeSession");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const child_process_1 = require("child_process");
@@ -371,6 +372,13 @@ async function initScopesCommand(args) {
 }
 async function watchAllScopesCommand(args) {
     (0, commands_1.setLogLevel)(args);
+    // Soft guard, not a hard fail: `watch` is a human-only local-dev tool and a
+    // branch switch mid-watch overwrites instance records. Warn an agent off it
+    // but leave the human path untouched. See TenonHQ/Dovetail#155.
+    if ((0, claudeSession_1.isClaudeCodeSession)()) {
+        Logger_1.logger.warn(claudeSession_1.WATCH_HUMAN_ONLY_WARNING);
+        FileLogger_1.fileLogger.warn("dove watch started inside a Claude Code session (TenonHQ/Dovetail#155)");
+    }
     var dashboardProcess = null;
     try {
         // First check if we have environment variables set. SN_USER stays

package/dist/claudeSession.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Claude Code session detection for human-only CLI surfaces.
+ *
+ * `dove watch` auto-syncs the working tree to the instance, and a git branch
+ * switch mid-watch pushes the post-switch file state over live records. An
+ * agent can't guarantee it stops the watcher before every branch operation, so
+ * the command is hidden from `--help` and warns when it detects it is running
+ * inside a Claude Code session. See TenonHQ/Dovetail#155.
+ *
+ * Pure functions — no I/O — so the detection is unit-testable without touching
+ * `process.env` directly.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WATCH_HUMAN_ONLY_WARNING = void 0;
+exports.isClaudeCodeSession = isClaudeCodeSession;
+// Claude Code exports `CLAUDECODE=1` into every tool shell, plus a family of
+// `CLAUDE_CODE_*` variables (e.g. `CLAUDE_CODE_SESSION_ID`, which claude-plans
+// already keys on). Any one of them set to a non-empty value is a session.
+var CLAUDE_SESSION_FLAG = "CLAUDECODE";
+var CLAUDE_SESSION_PREFIX = "CLAUDE_CODE_";
+/**
+ * @description Human-only warning printed when `dove watch` starts inside a
+ * Claude Code session. Non-blocking by design (TenonHQ/Dovetail#155).
+ */
+exports.WATCH_HUMAN_ONLY_WARNING = "⚠ `dove watch` is a human-only local-dev tool — it auto-syncs to the " +
+    "instance and a branch switch mid-watch overwrites records. Don't run this " +
+    "inside Claude Code. Use `npx dove push --diff <branch>` / `npx dove refresh` / " +
+    "`npx dove status` instead. See TenonHQ/Dovetail#155.";
+/**
+ * @description Reports whether the given environment looks like a Claude Code
+ * session: `CLAUDECODE` is set, or any `CLAUDE_CODE_*` variable is set, to a
+ * non-empty value. Empty strings do not count — an unset-but-declared variable
+ * is not a session.
+ * @param {NodeJS.ProcessEnv} env - Environment to inspect (defaults to `process.env`).
+ * @returns {boolean} True when a Claude Code session is detected.
+ */
+function isClaudeCodeSession(env = process.env) {
+    if (!env || typeof env !== "object")
+        return false;
+    if (hasValue(env[CLAUDE_SESSION_FLAG]))
+        return true;
+    var keys = Object.keys(env);
+    for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        if (key.indexOf(CLAUDE_SESSION_PREFIX) === 0 && hasValue(env[key]))
+            return true;
+    }
+    return false;
+}
+/**
+ * @description True when an env value is a non-empty string.
+ * @param {string|undefined} value - Raw env value.
+ * @returns {boolean} Whether the value counts as "set".
+ */
+function hasValue(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}

package/dist/commander.js

@@ -49,7 +49,17 @@ function configureCli(cli) {
         describe: "Write a dovetail-debug-*.log file for this command (off by default; also enabled by DOVETAIL_DEBUG=1).",
     })
         .global("debug")
-        .command(["watch", "w", "watchAllScopes"], "Watch all scopes for file changes and sync to ServiceNow", (cmdArgs) => {
+        // INTENTIONAL: 'watch' is hidden from help + Claude-facing docs. It
+        // auto-syncs to the instance and a branch switch mid-watch silently
+        // overwrites records. Human-only local-dev tool. Do not re-document for
+        // Claude. See TenonHQ/Dovetail#155.
+        //
+        // A `false` description is yargs' hidden-command pattern: the command stays
+        // fully wired (a human typing `dove watch` / `w` / `watchAllScopes` still
+        // gets it, and `dove watch --help` still prints its flags) but it is omitted
+        // from the `dove --help` command index. The handler itself prints a
+        // human-only warning when it detects a Claude Code session (claudeSession.ts).
+        .command(["watch", "w", "watchAllScopes"], false, (cmdArgs) => {
         cmdArgs.options({
             ...sharedOptions,
             noDashboard: {

package/dist/tests/claudeSession.test.js

@@ -0,0 +1,42 @@
+"use strict";
+// Tests for the Claude Code session detector behind the `dove watch` soft
+// guard (claudeSession.ts, TenonHQ/Dovetail#155). Pure-function tests — an
+// 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("isClaudeCodeSession", function () {
+    it("returns false for an empty environment", function () {
+        expect((0, claudeSession_1.isClaudeCodeSession)({})).toBe(false);
+    });
+    it("returns false when only unrelated variables are set", function () {
+        expect((0, claudeSession_1.isClaudeCodeSession)({ HOME: "/tmp", SN_INSTANCE: "x.service-now.com" })).toBe(false);
+    });
+    it("returns true when CLAUDECODE is set", function () {
+        expect((0, claudeSession_1.isClaudeCodeSession)({ CLAUDECODE: "1" })).toBe(true);
+    });
+    it("returns true when any CLAUDE_CODE_* variable is set", function () {
+        expect((0, claudeSession_1.isClaudeCodeSession)({ CLAUDE_CODE_SESSION_ID: "abc123" })).toBe(true);
+        expect((0, claudeSession_1.isClaudeCodeSession)({ CLAUDE_CODE_ENTRYPOINT: "cli" })).toBe(true);
+    });
+    it("treats empty or whitespace-only values as unset", function () {
+        expect((0, claudeSession_1.isClaudeCodeSession)({ CLAUDECODE: "" })).toBe(false);
+        expect((0, claudeSession_1.isClaudeCodeSession)({ CLAUDE_CODE_SESSION_ID: "   " })).toBe(false);
+    });
+    it("does not match look-alike prefixes", function () {
+        expect((0, claudeSession_1.isClaudeCodeSession)({ CLAUDE: "1", CLAUDECODEX: "1", MY_CLAUDE_CODE_X: "1" })).toBe(false);
+    });
+    it("defaults to process.env and agrees with an explicit copy of it", function () {
+        expect((0, claudeSession_1.isClaudeCodeSession)()).toBe((0, claudeSession_1.isClaudeCodeSession)({ ...process.env }));
+    });
+});
+describe("WATCH_HUMAN_ONLY_WARNING", function () {
+    it("names the hazard, the safe headless verbs, and the tracking issue", function () {
+        expect(claudeSession_1.WATCH_HUMAN_ONLY_WARNING).toContain("human-only");
+        expect(claudeSession_1.WATCH_HUMAN_ONLY_WARNING).toContain("branch switch");
+        expect(claudeSession_1.WATCH_HUMAN_ONLY_WARNING).toContain("Claude Code");
+        expect(claudeSession_1.WATCH_HUMAN_ONLY_WARNING).toContain("dove push");
+        expect(claudeSession_1.WATCH_HUMAN_ONLY_WARNING).toContain("dove refresh");
+        expect(claudeSession_1.WATCH_HUMAN_ONLY_WARNING).toContain("dove status");
+        expect(claudeSession_1.WATCH_HUMAN_ONLY_WARNING).toContain("TenonHQ/Dovetail#155");
+    });
+});

package/dist/tests/dovetailUtilsMSTableOptions.test.js

@@ -0,0 +1,460 @@
+"use strict";
+/**
+ * Tests the SERVER half of the sync engine — servicenow/dovetail/sys_script_include/
+ * DovetailUtilsMS.js — for the two table options that make platform-config tables
+ * syncable per scope:
+ *
+ *  - `scopeQuery`: sys_choice rows carry NO sys_scope (verified on tenonworkstudio:
+ *    `sys_scopeISEMPTY` returns every x_cadso_automate_* choice), so the table is never
+ *    a sys_metadata child of any app — getTableNames can't discover it and the
+ *    sys_scope filter in buildTableMap would return zero rows. scopeQuery replaces that
+ *    filter with an encoded query ("nameSTARTSWITH{scope}_") and lists the table.
+ *  - `nameTemplate`: sys_choice.label / sys_dictionary.column_label collide across tables
+ *    and fields, so the display-value folder name would be "Failed (1a2b3c4d)" ×N.
+ *    "{name}.{element}.{value}" names the folder from the fields that ARE unique.
+ *
+ * Same sandbox approach as dovetailUtilsMSCollision.test.ts: the real script include is
+ * loaded with minimal ServiceNow stubs so the test fails if the deployed source regresses.
+ */
+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 path_1 = __importDefault(require("path"));
+const vm_1 = __importDefault(require("vm"));
+const SOURCE = path_1.default.join(__dirname, "../../../../servicenow/dovetail/sys_script_include/DovetailUtilsMS.js");
+/**
+ * GlideRecord stub over a fixture list. Records the queries it receives so a test can
+ * assert WHICH filter buildTableMap applied (sys_scope vs the rendered scopeQuery).
+ * `validFields` controls isValidField — sys_choice has no sys_class_name column.
+ */
+function makeGlideRecord(rows, captured, validFields) {
+    return function GlideRecordStub(_table) {
+        var i = -1;
+        this.get = function (sysIdOrField, value) {
+            if (value !== undefined) {
+                // sys_app lookup by scope name → one row with a sys_id
+                i = rows.findIndex(function (r) {
+                    return r[sysIdOrField] === value;
+                });
+                return i !== -1;
+            }
+            i = rows.findIndex(function (r) {
+                return r.sys_id === sysIdOrField;
+            });
+            return i !== -1;
+        };
+        this.addQuery = function (field, value) {
+            captured.fieldQueries.push({ field: field, value: value });
+            return { addOrCondition: function () { } };
+        };
+        this.addEncodedQuery = function (q) {
+            captured.encodedQueries.push(q);
+        };
+        this.isValidField = function (field) {
+            return validFields === null ? true : validFields.indexOf(field) !== -1;
+        };
+        this.query = function () {
+            i = -1;
+        };
+        this.next = function () {
+            i += 1;
+            return i < rows.length;
+        };
+        this.getValue = function (field) {
+            var v = rows[i][field];
+            return v === undefined ? null : v;
+        };
+        this.getDisplayValue = function (field) {
+            return field ? rows[i][field] : rows[i].label || rows[i].name;
+        };
+        this.getElement = function (field) {
+            var v = rows[i][field];
+            return {
+                getDisplayValue: function () {
+                    return v === undefined ? "" : v;
+                },
+            };
+        };
+        this.getElements = function () {
+            return null;
+        };
+    };
+}
+function loadUtils(opts) {
+    const rows = opts.rows || [];
+    const warnings = [];
+    const captured = { encodedQueries: [], fieldQueries: [] };
+    const metadataClasses = opts.metadataClasses || [];
+    const sandbox = {
+        Class: {
+            create: function () {
+                return function () {
+                    if (this.initialize)
+                        this.initialize.apply(this, arguments);
+                };
+            },
+        },
+        GlideRecord: makeGlideRecord(rows, captured, opts.validFields === undefined ? null : opts.validFields),
+        // getTableNames aggregates sys_metadata by sys_class_name — one "row" per class.
+        GlideAggregate: function GlideAggregateStub() {
+            var i = -1;
+            this.addQuery = function () { };
+            this.groupBy = function () { };
+            this.query = function () {
+                i = -1;
+            };
+            this.next = function () {
+                i += 1;
+                return i < metadataClasses.length;
+            };
+            this.getValue = function () {
+                return metadataClasses[i];
+            };
+        },
+        gs: {
+            warn: function (msg) {
+                warnings.push(msg);
+            },
+            getProperty: function () {
+                return "https://example.service-now.com/";
+            },
+        },
+    };
+    vm_1.default.createContext(sandbox);
+    vm_1.default.runInContext(fs_1.default.readFileSync(SOURCE, "utf8"), sandbox);
+    return {
+        utils: new sandbox.DovetailUtilsMS(),
+        warnings: warnings,
+        captured: captured,
+    };
+}
+const CHOICE_ROWS = [
+    {
+        sys_id: "a21fd5c0c3bf0750d4ddf1db05013100",
+        name: "x_cadso_automate_message_batch_recipient",
+        element: "last_status",
+        value: "delivered",
+        label: "Delivered",
+    },
+    {
+        sys_id: "2e1f598c33ff07507b18bc534d5c7b46",
+        name: "x_cadso_automate_message_batch_recipient",
+        element: "last_status",
+        value: "failed",
+        label: "Failed",
+    },
+    {
+        sys_id: "b94a7244c3ec8750d4ddf1db0501315e",
+        name: "x_cadso_automate_message_batch_recipient",
+        element: "state",
+        value: "Failed",
+        label: "Failed",
+    },
+    {
+        sys_id: "11327be5c3384f90d4ddf1db050131a3",
+        name: "x_cadso_automate_message_batch",
+        element: "state",
+        value: "Failed",
+        label: "Failed",
+    },
+];
+function buildChoices(tableOptions, validFields = ["name", "element", "value", "label"]) {
+    const loaded = loadUtils({ rows: CHOICE_ROWS, validFields: validFields });
+    const result = loaded.utils.buildTableMap({
+        tableName: "sys_choice",
+        scopeId: "5e9f5f8b87420250369f33373cbb3559",
+        scopeName: "x_cadso_automate",
+        getContents: false,
+        includes: { sys_choice: { label: { type: "txt" } } },
+        excludes: {},
+        tableOptions: tableOptions,
+    });
+    return {
+        records: result.records,
+        warnings: loaded.warnings,
+        captured: loaded.captured,
+    };
+}
+describe("DovetailUtilsMS.buildTableMap — scopeQuery", () => {
+    it("replaces the sys_scope filter with the rendered scopeQuery ({scope} → scope name)", () => {
+        const out = buildChoices({ scopeQuery: "nameSTARTSWITH{scope}_" });
+        expect(out.captured.encodedQueries).toContain("nameSTARTSWITHx_cadso_automate_");
+        const scopeFilters = out.captured.fieldQueries.filter((q) => q.field === "sys_scope");
+        expect(scopeFilters).toHaveLength(0);
+    });
+    it("renders {scopeId} as the scope sys_id", () => {
+        const out = buildChoices({ scopeQuery: "sys_package={scopeId}" });
+        expect(out.captured.encodedQueries).toContain("sys_package=5e9f5f8b87420250369f33373cbb3559");
+    });
+    it("keeps the sys_scope filter when no scopeQuery is set (existing behaviour)", () => {
+        const out = buildChoices({});
+        const scopeFilters = out.captured.fieldQueries.filter((q) => q.field === "sys_scope");
+        expect(scopeFilters).toEqual([
+            { field: "sys_scope", value: "5e9f5f8b87420250369f33373cbb3559" },
+        ]);
+    });
+    it("still ANDs the plain `query` option on top of scopeQuery", () => {
+        const out = buildChoices({
+            scopeQuery: "nameSTARTSWITH{scope}_",
+            query: "language=en",
+        });
+        expect(out.captured.encodedQueries).toEqual([
+            "nameSTARTSWITHx_cadso_automate_",
+            "language=en",
+        ]);
+    });
+    it("skips the sys_class_name query on a table that has no such column (sys_choice)", () => {
+        const out = buildChoices({ scopeQuery: "nameSTARTSWITH{scope}_" }, [
+            "name",
+            "element",
+            "value",
+            "label",
+        ]);
+        const classFilters = out.captured.fieldQueries.filter((q) => q.field === "sys_class_name");
+        expect(classFilters).toHaveLength(0);
+    });
+    it("keeps the sys_class_name query on a table that has the column", () => {
+        const out = buildChoices({}, null);
+        const classFilters = out.captured.fieldQueries.filter((q) => q.field === "sys_class_name");
+        expect(classFilters).toEqual([
+            { field: "sys_class_name", value: "sys_choice" },
+        ]);
+    });
+    it("treats an empty scopeQuery as unset", () => {
+        const out = buildChoices({ scopeQuery: "" });
+        const scopeFilters = out.captured.fieldQueries.filter((q) => q.field === "sys_scope");
+        expect(scopeFilters).toHaveLength(1);
+        expect(out.captured.encodedQueries).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}" });
+        expect(Object.keys(out.records).sort()).toEqual([
+            "x_cadso_automate_message_batch.state.Failed",
+            "x_cadso_automate_message_batch_recipient.last_status.delivered",
+            "x_cadso_automate_message_batch_recipient.last_status.failed",
+            "x_cadso_automate_message_batch_recipient.state.Failed",
+        ]);
+        expect(out.warnings).toHaveLength(0);
+    });
+    it("without a template, three 'Failed' labels collapse into the sys_id-suffixed collision set", () => {
+        const out = buildChoices({});
+        const keys = Object.keys(out.records).sort();
+        expect(keys).toEqual([
+            "Delivered",
+            "Failed (11327be5)",
+            "Failed (2e1f598c)",
+            "Failed (b94a7244)",
+        ]);
+    });
+    it("keeps record.name identical to the map key", () => {
+        const out = buildChoices({ nameTemplate: "{name}.{element}.{value}" });
+        Object.keys(out.records).forEach((key) => {
+            expect(out.records[key].name).toBe(key);
+        });
+    });
+    it("drops an empty token together with the literal before it (sys_dictionary collection row)", () => {
+        const loaded = loadUtils({
+            rows: [
+                {
+                    sys_id: "c85856cec3a44b10d4ddf1db05013158",
+                    name: "x_cadso_automate_message_batch_recipient",
+                    element: "last_status",
+                },
+                {
+                    sys_id: "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a",
+                    name: "x_cadso_automate_message_batch_recipient",
+                    element: "",
+                },
+                {
+                    sys_id: "1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b",
+                    name: "x_cadso_automate_message_batch",
+                },
+            ],
+        });
+        const result = loaded.utils.buildTableMap({
+            tableName: "sys_dictionary",
+            scopeId: "scope1",
+            scopeName: "x_cadso_automate",
+            getContents: false,
+            includes: { sys_dictionary: { column_label: { type: "txt" } } },
+            excludes: {},
+            tableOptions: { nameTemplate: "{name}.{element}" },
+        });
+        expect(Object.keys(result.records).sort()).toEqual([
+            "x_cadso_automate_message_batch",
+            "x_cadso_automate_message_batch_recipient",
+            "x_cadso_automate_message_batch_recipient.last_status",
+        ]);
+    });
+    it("drops a leading empty token and its following literal", () => {
+        const loaded = loadUtils({
+            rows: [{ sys_id: "aaaaaaaa11111111", element: "state", value: "x" }],
+        });
+        const result = loaded.utils.buildTableMap({
+            tableName: "t",
+            scopeId: "s",
+            scopeName: "x",
+            getContents: false,
+            includes: { t: { value: { type: "txt" } } },
+            excludes: {},
+            tableOptions: { nameTemplate: "{name}.{element}.{value}" },
+        });
+        expect(Object.keys(result.records)).toEqual(["state.x"]);
+    });
+    it("falls back to sys_id when every token is empty", () => {
+        const loaded = loadUtils({ rows: [{ sys_id: "aaaaaaaa11111111" }] });
+        const result = loaded.utils.buildTableMap({
+            tableName: "t",
+            scopeId: "s",
+            scopeName: "x",
+            getContents: false,
+            includes: { t: { value: { type: "txt" } } },
+            excludes: {},
+            tableOptions: { nameTemplate: "{name}.{element}" },
+        });
+        expect(Object.keys(result.records)).toEqual(["aaaaaaaa11111111"]);
+    });
+    it("sanitizes path separators in template values", () => {
+        const loaded = loadUtils({
+            rows: [{ sys_id: "aaaaaaaa11111111", name: "t", value: "a/b\\c" }],
+        });
+        const result = loaded.utils.buildTableMap({
+            tableName: "t",
+            scopeId: "s",
+            scopeName: "x",
+            getContents: false,
+            includes: { t: { value: { type: "txt" } } },
+            excludes: {},
+            tableOptions: { nameTemplate: "{name}.{value}" },
+        });
+        expect(Object.keys(result.records)).toEqual(["t.a〳b〳c"]);
+    });
+    it("wins over displayField / differentiatorField when both are set", () => {
+        const out = buildChoices({
+            nameTemplate: "{element}.{value}",
+            displayField: "label",
+            differentiatorField: "sys_id",
+        });
+        expect(Object.keys(out.records).sort()).toEqual([
+            "last_status.delivered",
+            "last_status.failed",
+            "state.Failed (11327be5)",
+            "state.Failed (b94a7244)",
+        ]);
+        // Two tables share element+value here — the collision guard still catches it.
+        expect(out.warnings).toHaveLength(2);
+    });
+    it("applies the template in processMissingFiles (bulkDownload) too", () => {
+        const loaded = loadUtils({ rows: CHOICE_ROWS });
+        const recordMap = {};
+        CHOICE_ROWS.forEach((r) => {
+            recordMap[r.sys_id] = [{ name: "label", type: "txt" }];
+        });
+        const result = loaded.utils.processMissingFiles({ sys_choice: recordMap }, { sys_choice: { nameTemplate: "{name}.{element}.{value}" } });
+        expect(Object.keys(result.sys_choice.records).sort()).toEqual([
+            "x_cadso_automate_message_batch.state.Failed",
+            "x_cadso_automate_message_batch_recipient.last_status.delivered",
+            "x_cadso_automate_message_batch_recipient.last_status.failed",
+            "x_cadso_automate_message_batch_recipient.state.Failed",
+        ]);
+    });
+});
+describe("DovetailUtilsMS.getTableNames — scopeQuery tables are listed explicitly", () => {
+    it("adds a scopeQuery table that sys_metadata cannot surface", () => {
+        const loaded = loadUtils({
+            metadataClasses: ["sys_script_include", "sys_dictionary"],
+        });
+        const tables = loaded.utils.getTableNames({
+            scopeId: "scope1",
+            includes: { sys_choice: { label: { type: "txt" } } },
+            excludes: {},
+            tableOptions: { sys_choice: { scopeQuery: "nameSTARTSWITH{scope}_" } },
+        });
+        expect(tables).toEqual([
+            "sys_script_include",
+            "sys_dictionary",
+            "sys_choice",
+        ]);
+    });
+    it("does not duplicate a table sys_metadata already surfaced", () => {
+        const loaded = loadUtils({ metadataClasses: ["sys_dictionary"] });
+        const tables = loaded.utils.getTableNames({
+            scopeId: "scope1",
+            includes: {},
+            excludes: {},
+            tableOptions: { sys_dictionary: { scopeQuery: "nameSTARTSWITHx_" } },
+        });
+        expect(tables).toEqual(["sys_dictionary"]);
+    });
+    it("respects excludes for scopeQuery tables", () => {
+        const loaded = loadUtils({ metadataClasses: [] });
+        const tables = loaded.utils.getTableNames({
+            scopeId: "scope1",
+            includes: {},
+            excludes: { sys_choice: true },
+            tableOptions: { sys_choice: { scopeQuery: "nameSTARTSWITH{scope}_" } },
+        });
+        expect(tables).toEqual([]);
+    });
+    it("ignores tableOptions without a scopeQuery (query / nameTemplate alone do not list a table)", () => {
+        const loaded = loadUtils({ metadataClasses: [] });
+        const tables = loaded.utils.getTableNames({
+            scopeId: "scope1",
+            includes: {},
+            excludes: {},
+            tableOptions: {
+                sys_choice: { nameTemplate: "{name}" },
+                sys_dictionary: { query: "a=b" },
+            },
+        });
+        expect(tables).toEqual([]);
+    });
+    it("tolerates a missing tableOptions argument (existing callers)", () => {
+        const loaded = loadUtils({ metadataClasses: ["sys_script"] });
+        const tables = loaded.utils.getTableNames({
+            scopeId: "scope1",
+            includes: {},
+            excludes: {},
+        });
+        expect(tables).toEqual(["sys_script"]);
+    });
+});
+describe("DovetailUtilsMS.getManifest — wiring", () => {
+    it("passes scopeName into buildTableMap so scopeQuery renders, and lists the scope-less table", () => {
+        const loaded = loadUtils({
+            // sys_app lookup row (getScopeId does appGR.get("scope", name)) + the choice rows
+            rows: [
+                {
+                    sys_id: "5e9f5f8b87420250369f33373cbb3559",
+                    scope: "x_cadso_automate",
+                },
+            ].concat(CHOICE_ROWS),
+            metadataClasses: [],
+            validFields: ["name", "element", "value", "label", "scope"],
+        });
+        const manifest = loaded.utils.getManifest({
+            scopeName: "x_cadso_automate",
+            includes: { sys_choice: { label: { type: "txt" } } },
+            excludes: {},
+            tableOptions: {
+                sys_choice: {
+                    scopeQuery: "nameSTARTSWITH{scope}_",
+                    nameTemplate: "{name}.{element}.{value}",
+                },
+            },
+            getContents: false,
+        });
+        expect(loaded.captured.encodedQueries).toContain("nameSTARTSWITHx_cadso_automate_");
+        expect(Object.keys(manifest.tables)).toEqual(["sys_choice"]);
+        // The stub GlideRecord iterates every fixture row regardless of query, so the
+        // sys_app row shows up too (named by sys_id: no name/element/value). What matters
+        // here is that the four choice rows are present under their templated names.
+        const keys = Object.keys(manifest.tables.sys_choice.records);
+        expect(keys).toContain("x_cadso_automate_message_batch_recipient.last_status.delivered");
+        expect(keys).toContain("x_cadso_automate_message_batch.state.Failed");
+    });
+});