@tenonhq/dovetail-core 0.0.106 → 0.0.108

package/dist/FileLogger.js

@@ -37,6 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fileLogger = void 0;
+exports.shouldEnableFileLogging = shouldEnableFileLogging;
 exports.enableFileLogging = enableFileLogging;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -45,14 +46,58 @@ const chalk_1 = __importDefault(require("chalk"));
 // Long-running sessions (e.g. `dove watch`) would otherwise grow a single
 // debug log unbounded; capping at 200 writes per file keeps each one small.
 const ROTATION_WRITE_LIMIT = 200;
+// Truthy spellings accepted for the DOVETAIL_DEBUG env var.
+const TRUTHY = /^(1|true|yes|on)$/i;
+/**
+ * @description Decide whether the file logger should write `dovetail-debug-*.log`
+ * files to disk. File logging is OFF by default and only turns on when the user
+ * explicitly opts in — either the `--debug` CLI flag (`--debug` or
+ * `--debug=<truthy>`) or the `DOVETAIL_DEBUG` env var set to a truthy value.
+ * Pure and side-effect free so it can be unit-tested with injected inputs.
+ * @param {string[]} argv - CLI args after the node + script entries (process.argv.slice(2)).
+ * @param {NodeJS.ProcessEnv} env - Environment map (defaults to an empty object).
+ * @returns {boolean} true when file logging should be enabled.
+ */
+function shouldEnableFileLogging(argv = [], env = {}) {
+    const raw = typeof env.DOVETAIL_DEBUG === "string" ? env.DOVETAIL_DEBUG.trim() : "";
+    if (TRUTHY.test(raw))
+        return true;
+    const args = Array.isArray(argv) ? argv : [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--debug")
+            return true;
+        const eq = typeof arg === "string" ? arg.match(/^--debug=(.*)$/) : null;
+        if (eq)
+            return TRUTHY.test(eq[1].trim());
+    }
+    return false;
+}
 class FileLogger {
     logFilePath;
     logStream = null;
     initialized = false;
     writeCount = 0;
+    // File logging is opt-in — nothing touches disk unless this is true. Seeded
+    // from `--debug` / DOVETAIL_DEBUG so a stray log file is never created just by
+    // running a command; can also be flipped on at runtime via enable().
+    enabled;
     constructor() {
         // Initialize on first use
         this.logFilePath = "";
+        this.enabled = shouldEnableFileLogging(Array.isArray(process.argv) ? process.argv.slice(2) : [], process.env);
+    }
+    /**
+     * Turn file logging on for this process (programmatic opt-in). Idempotent.
+     */
+    enable() {
+        this.enabled = true;
+    }
+    /**
+     * Whether file logging is currently active.
+     */
+    isEnabled() {
+        return this.enabled;
     }
     /**
      * Initialize the file logger in the current working directory
@@ -109,6 +154,11 @@ class FileLogger {
      * Write a message to the log file
      */
     writeToFile(message) {
+        // Opt-in gate: without --debug / DOVETAIL_DEBUG we never create or write a
+        // log file. Console output (info/warn/error/success) still happens because
+        // those methods log to the console before calling writeToFile.
+        if (!this.enabled)
+            return;
         if (!this.initialized) {
             this.initialize();
         }
@@ -215,6 +265,8 @@ const fileLogger = new FileLogger();
 exports.fileLogger = fileLogger;
 // Also export a function to replace console.log globally
 function enableFileLogging() {
+    // Opt in to file logging even if neither --debug nor DOVETAIL_DEBUG was set.
+    fileLogger.enable();
     // Store original console.log
     const originalConsoleLog = console.log;
     // Override console.log to also write to file

package/dist/appUtils.js

@@ -38,30 +38,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAndAssignUpdateSet = exports.swapScope = exports.buildFiles = exports.summarizeRecord = exports.pushFiles = exports.getAppFileList = exports.groupAppFiles = exports.processMissingFiles = exports.refreshAllFiles = exports.findMissingFiles = exports.syncManifest = exports.processManifest = exports.normalizeManifestKeys = exports.toSafeFolderName = exports.stampMetadataContent = void 0;
 const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
 const progress_1 = __importDefault(require("progress"));
 const fUtils = __importStar(require("./FileUtils"));
 const ConfigManager = __importStar(require("./config"));
 const constants_1 = require("./constants");
 const PluginManager_1 = __importDefault(require("./PluginManager"));
 const FileLogger_1 = require("./FileLogger");
-const projectFiles_1 = require("./projectFiles");
+const updateSetConfig_1 = require("./updateSetConfig");
 const snClient_1 = require("./snClient");
 const benchmark_1 = require("./benchmark");
 const Logger_1 = require("./Logger");
 const genericUtils_1 = require("./genericUtils");
-const getUpdateSetConfig = () => {
-    const configPath = (0, projectFiles_1.getUpdateSetsConfigPath)();
-    try {
-        if (fs_1.default.existsSync(configPath)) {
-            return JSON.parse(fs_1.default.readFileSync(configPath, "utf8"));
-        }
-    }
-    catch (e) {
-        Logger_1.logger.warn(`Failed to parse update set config at ${configPath}: ${e instanceof Error ? e.message : String(e)}`);
-    }
-    return {};
-};
+// Delegate to the shared reader so the push hot-path and the
+// createUpdateSet/switchUpdateSet writers stay on one parse contract.
+const getUpdateSetConfig = () => (0, updateSetConfig_1.readUpdateSetConfig)();
 // Strip the ServiceNow instance host from an absolute _record_link, leaving the
 // instance-relative path. The CADSO metadata endpoint returns an absolute URL
 // (https://<instance>.service-now.com/<table>.do?sys_id=...); persisting that
@@ -762,9 +752,11 @@ const pushFiles = async (recs) => {
     const hasUpdateSets = Object.keys(updateSetConfig).length > 0;
     if (hasUpdateSets) {
         const activeScopes = Object.entries(updateSetConfig)
-            .map(([scope, us]) => `${scope} -> ${us.name}`)
+            .map(([scope, us]) => `${scope} -> ${us.name} (${us.sys_id})`)
             .join(", ");
-        Logger_1.logger.info(`Update set routing active: ${activeScopes}`);
+        // Name the source file and show the sys_id so the operator can see exactly
+        // where captures land — push routes by this file, not the active set (#182).
+        Logger_1.logger.info(`Update set routing (from .dove-update-sets.json): ${activeScopes}`);
     }
     // Pre-resolve read-only table sets for every scope present in this batch.
     // Cheaper than re-resolving per record. Tables flagged in _readOnlyTables
@@ -971,6 +963,20 @@ const createAndAssignUpdateSet = async (updateSetName = "", scope) => {
     else {
         await client.createCurrentUpdateSetUserPref(updateSetSysId, userSysId);
     }
+    // Route this scope's captures to the new set. pushFiles() routes by
+    // .dove-update-sets.json, not the active set, so without this a `dove push
+    // --updateSet` could create+activate a set yet capture into a stale one
+    // (TenonHQ/Dovetail#182). Only possible when the scope name is known.
+    if (scope) {
+        const routed = (0, updateSetConfig_1.writeUpdateSetRouting)({
+            scope,
+            sysId: updateSetSysId,
+            name: updateSetName,
+        });
+        if (routed) {
+            Logger_1.logger.info(`Push routing updated: ${scope} -> ${updateSetName} (${updateSetSysId})`);
+        }
+    }
     return {
         name: updateSetName,
         id: updateSetSysId,

package/dist/commander.js

@@ -31,6 +31,12 @@ async function initCommands() {
         describe: "Path to a .env file to load for this command (default: .env in the project root). Lets one checkout target multiple instances.",
     })
         .global("env")
+        .option("debug", {
+        type: "boolean",
+        default: false,
+        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) => {
         cmdArgs.options({
             ...sharedOptions,

package/dist/snClient.js

@@ -334,6 +334,15 @@ const snClient = (baseURL, username, password) => {
             },
         });
     };
+    const getScopeById = (scopeSysId) => {
+        const endpoint = "api/now/table/sys_scope";
+        return client.get(endpoint, {
+            params: {
+                sysparm_query: `sys_id=${scopeSysId}`,
+                sysparm_fields: "scope",
+            },
+        });
+    };
     const getUserSysId = (userName = process.env.SN_USER) => {
         const endpoint = "api/now/table/sys_user";
         return client.get(endpoint, {
@@ -504,6 +513,7 @@ const snClient = (baseURL, username, password) => {
         getAppList,
         updateRecord,
         getScopeId,
+        getScopeById,
         getUserSysId,
         getCurrentAppUserPrefSysId,
         updateCurrentAppUserPref,

package/dist/tests/fileLoggerEnableGate.test.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * Regression: `dove` used to drop a `dovetail-debug-*.log` file into the cwd on
+ * EVERY invocation, because the file logger lazily created its file on the first
+ * write and `index.ts` logs "Starting Dovetail..." (plus scattered debug traces)
+ * on every command. The file logger is now opt-in — it only touches disk when
+ * the user asks for it via `--debug` or `DOVETAIL_DEBUG`.
+ *
+ * These tests cover:
+ *  - the pure decision helper (`shouldEnableFileLogging`), and
+ *  - the singleton's disk behavior: writes no file by default, writes once
+ *    enabled, while console output is unaffected in both states.
+ */
+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 FileLogger_1 = require("../FileLogger");
+function countDebugLogs(dir) {
+    return fs.readdirSync(dir).filter((f) => /^dovetail-debug-.*\.log$/.test(f))
+        .length;
+}
+// The file logger opens its stream asynchronously; poll until a predicate holds.
+async function waitFor(predicate, timeoutMs = 2000) {
+    const start = Date.now();
+    while (!predicate()) {
+        if (Date.now() - start > timeoutMs) {
+            throw new Error("waitFor: condition not met before timeout");
+        }
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+}
+describe("shouldEnableFileLogging (pure)", () => {
+    it("is OFF by default — no flag, no env", () => {
+        expect((0, FileLogger_1.shouldEnableFileLogging)([], {})).toBe(false);
+        expect((0, FileLogger_1.shouldEnableFileLogging)(["push", "--diff", "main"], {})).toBe(false);
+    });
+    it("turns ON with the --debug flag", () => {
+        expect((0, FileLogger_1.shouldEnableFileLogging)(["push", "--debug"], {})).toBe(true);
+        expect((0, FileLogger_1.shouldEnableFileLogging)(["--debug", "status"], {})).toBe(true);
+    });
+    it("honors --debug=<value>", () => {
+        expect((0, FileLogger_1.shouldEnableFileLogging)(["--debug=true"], {})).toBe(true);
+        expect((0, FileLogger_1.shouldEnableFileLogging)(["--debug=1"], {})).toBe(true);
+        expect((0, FileLogger_1.shouldEnableFileLogging)(["--debug=false"], {})).toBe(false);
+        expect((0, FileLogger_1.shouldEnableFileLogging)(["--debug=0"], {})).toBe(false);
+    });
+    it("turns ON with a truthy DOVETAIL_DEBUG env var", () => {
+        for (const v of ["1", "true", "TRUE", "yes", "on", " on "]) {
+            expect((0, FileLogger_1.shouldEnableFileLogging)([], { DOVETAIL_DEBUG: v })).toBe(true);
+        }
+    });
+    it("stays OFF for a falsy/empty DOVETAIL_DEBUG env var", () => {
+        for (const v of ["", "0", "false", "no", "off"]) {
+            expect((0, FileLogger_1.shouldEnableFileLogging)([], { DOVETAIL_DEBUG: v })).toBe(false);
+        }
+    });
+    it("tolerates non-array argv defensively", () => {
+        expect((0, FileLogger_1.shouldEnableFileLogging)(undefined, {})).toBe(false);
+    });
+});
+describe("fileLogger disk gate", () => {
+    let tmpDir;
+    let cwdSpy;
+    let logSpy;
+    let errSpy;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "dovetail-log-gate-"));
+        cwdSpy = jest.spyOn(process, "cwd").mockReturnValue(tmpDir);
+        logSpy = jest.spyOn(console, "log").mockImplementation(() => undefined);
+        errSpy = jest.spyOn(console, "error").mockImplementation(() => undefined);
+    });
+    afterEach(async () => {
+        FileLogger_1.fileLogger.close();
+        // Let any in-flight stream close settle before removing the directory.
+        await new Promise((resolve) => setTimeout(resolve, 20));
+        cwdSpy.mockRestore();
+        logSpy.mockRestore();
+        errSpy.mockRestore();
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("writes NO log file when disabled (jest runs with no --debug / env)", () => {
+        expect(FileLogger_1.fileLogger.isEnabled()).toBe(false);
+        FileLogger_1.fileLogger.debug("should not create a file");
+        FileLogger_1.fileLogger.info("informational");
+        FileLogger_1.fileLogger.warn("warning");
+        FileLogger_1.fileLogger.error("boom");
+        expect(countDebugLogs(tmpDir)).toBe(0);
+        expect(FileLogger_1.fileLogger.getLogFilePath()).toBe("");
+    });
+    it("still prints info to the console when disabled", () => {
+        FileLogger_1.fileLogger.info("visible to the user");
+        expect(logSpy).toHaveBeenCalled();
+    });
+    it("creates and writes a log file once enabled", async () => {
+        FileLogger_1.fileLogger.enable();
+        expect(FileLogger_1.fileLogger.isEnabled()).toBe(true);
+        FileLogger_1.fileLogger.debug("now this lands on disk");
+        // Path is assigned synchronously in initialize(); the stream opens async.
+        const logPath = FileLogger_1.fileLogger.getLogFilePath();
+        expect(logPath.startsWith(tmpDir)).toBe(true);
+        expect(/dovetail-debug-.*\.log$/.test(path.basename(logPath))).toBe(true);
+        await waitFor(() => fs.existsSync(logPath) &&
+            fs.readFileSync(logPath, "utf8").includes("now this lands on disk"));
+        expect(countDebugLogs(tmpDir)).toBe(1);
+    });
+});

package/dist/tests/updateSetConfig.test.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * TenonHQ/Dovetail#182: readUpdateSetConfig / writeUpdateSetRouting
+ *
+ * The push-routing file (.dove-update-sets.json) is the source of truth for
+ * `dove push`. These tests pin the read/merge/write contract that keeps it in
+ * sync with createUpdateSet / switchUpdateSet.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var mockFsStore = {};
+jest.mock("fs", function () {
+    return {
+        existsSync: jest.fn(function (p) {
+            return p in mockFsStore;
+        }),
+        readFileSync: jest.fn(function (p) {
+            if (p in mockFsStore)
+                return mockFsStore[p];
+            throw new Error("ENOENT: " + p);
+        }),
+        writeFileSync: jest.fn(function (p, data) {
+            mockFsStore[p] = data;
+        }),
+    };
+});
+var CONFIG_PATH = "/repo/.dove-update-sets.json";
+jest.mock("../projectFiles", function () {
+    return {
+        getUpdateSetsConfigPath: jest.fn(function () {
+            return CONFIG_PATH;
+        }),
+    };
+});
+jest.mock("../Logger", function () {
+    return {
+        logger: {
+            info: jest.fn(),
+            error: jest.fn(),
+            warn: jest.fn(),
+            debug: jest.fn(),
+            success: jest.fn(),
+        },
+    };
+});
+const updateSetConfig_1 = require("../updateSetConfig");
+const Logger_1 = require("../Logger");
+describe("updateSetConfig", function () {
+    beforeEach(function () {
+        for (var k in mockFsStore)
+            delete mockFsStore[k];
+        jest.clearAllMocks();
+    });
+    describe("readUpdateSetConfig", function () {
+        test("returns {} when the file is absent", function () {
+            expect((0, updateSetConfig_1.readUpdateSetConfig)()).toEqual({});
+        });
+        test("parses an existing routing file", function () {
+            mockFsStore[CONFIG_PATH] = JSON.stringify({
+                x_cadso_core: { sys_id: "abc", name: "Set A" },
+            });
+            expect((0, updateSetConfig_1.readUpdateSetConfig)()).toEqual({
+                x_cadso_core: { sys_id: "abc", name: "Set A" },
+            });
+        });
+        test("returns {} and warns on unparseable JSON", function () {
+            mockFsStore[CONFIG_PATH] = "{ not json";
+            expect((0, updateSetConfig_1.readUpdateSetConfig)()).toEqual({});
+            expect(Logger_1.logger.warn).toHaveBeenCalled();
+        });
+        test("returns {} and warns when the file is a non-object (array)", function () {
+            mockFsStore[CONFIG_PATH] = JSON.stringify(["nope"]);
+            expect((0, updateSetConfig_1.readUpdateSetConfig)()).toEqual({});
+            expect(Logger_1.logger.warn).toHaveBeenCalled();
+        });
+    });
+    describe("writeUpdateSetRouting", function () {
+        test("writes a fresh routing entry and returns the path", function () {
+            var written = (0, updateSetConfig_1.writeUpdateSetRouting)({
+                scope: "x_cadso_core",
+                sysId: "new123",
+                name: "New Set",
+            });
+            expect(written).toBe(CONFIG_PATH);
+            expect(JSON.parse(mockFsStore[CONFIG_PATH])).toEqual({
+                x_cadso_core: { sys_id: "new123", name: "New Set" },
+            });
+        });
+        test("merges without clobbering other scopes", function () {
+            mockFsStore[CONFIG_PATH] = JSON.stringify({
+                x_cadso_automate: { sys_id: "keep", name: "Keep Me" },
+            });
+            (0, updateSetConfig_1.writeUpdateSetRouting)({
+                scope: "x_cadso_core",
+                sysId: "new123",
+                name: "New Set",
+            });
+            expect(JSON.parse(mockFsStore[CONFIG_PATH])).toEqual({
+                x_cadso_automate: { sys_id: "keep", name: "Keep Me" },
+                x_cadso_core: { sys_id: "new123", name: "New Set" },
+            });
+        });
+        test("overwrites the same scope's stale entry", function () {
+            mockFsStore[CONFIG_PATH] = JSON.stringify({
+                x_cadso_core: { sys_id: "old", name: "Old Set" },
+            });
+            (0, updateSetConfig_1.writeUpdateSetRouting)({
+                scope: "x_cadso_core",
+                sysId: "fresh",
+                name: "Fresh Set",
+            });
+            expect(JSON.parse(mockFsStore[CONFIG_PATH])).toEqual({
+                x_cadso_core: { sys_id: "fresh", name: "Fresh Set" },
+            });
+        });
+        test("returns null and writes nothing when scope is missing", function () {
+            var written = (0, updateSetConfig_1.writeUpdateSetRouting)({ sysId: "x", name: "y" });
+            expect(written).toBeNull();
+            expect(mockFsStore[CONFIG_PATH]).toBeUndefined();
+        });
+        test("returns null when sys_id or name is blank", function () {
+            expect((0, updateSetConfig_1.writeUpdateSetRouting)({ scope: "x_cadso_core", sysId: "  ", name: "y" })).toBeNull();
+            expect((0, updateSetConfig_1.writeUpdateSetRouting)({ scope: "x_cadso_core", sysId: "x", name: "" })).toBeNull();
+            expect(mockFsStore[CONFIG_PATH]).toBeUndefined();
+        });
+    });
+});

package/dist/updateSetCommands.js

@@ -49,6 +49,7 @@ const commands_1 = require("./commands");
 const chalk_1 = __importDefault(require("chalk"));
 const dovetail_clickup_1 = require("@tenonhq/dovetail-clickup");
 const clickupCommands_1 = require("./clickupCommands");
+const updateSetConfig_1 = require("./updateSetConfig");
 /**
  * Shows the current scope
  */
@@ -233,6 +234,26 @@ async function createUpdateSetCommand(args) {
         if (scope) {
             Logger_1.logger.info(`Scope: ${scope}`);
         }
+        // Keep .dove-update-sets.json in sync with the set we just activated.
+        // `dove push` routes captures by this file (per scope), not by the
+        // instance's active update set — so without this write the new set would
+        // stay empty and pushes would land in whatever stale set the file still
+        // points at (TenonHQ/Dovetail#182).
+        if (scope) {
+            const routed = (0, updateSetConfig_1.writeUpdateSetRouting)({
+                scope,
+                sysId: updateSetSysId,
+                name,
+            });
+            if (routed) {
+                Logger_1.logger.info(chalk_1.default.green(`✓ Push routing updated: ${scope} -> ${name} (${updateSetSysId})`));
+            }
+        }
+        else {
+            Logger_1.logger.warn("No scope provided, so .dove-update-sets.json was not updated. " +
+                "`dove push` routes captures by scope via that file — pass -s <scope> " +
+                "so pushes target this set, or edit .dove-update-sets.json directly.");
+        }
         // If created from a ClickUp task, offer to post a comment back
         if (args._clickupTaskId) {
             try {
@@ -292,6 +313,22 @@ async function switchUpdateSetCommand(args) {
         if (applicationName) {
             Logger_1.logger.info(`Scope: ${applicationName}`);
         }
+        // Keep .dove-update-sets.json in sync so `dove push` routes captures to the
+        // set we just switched to (it routes by this file per scope, not by the
+        // instance's active set — TenonHQ/Dovetail#182). `applicationScope` is the
+        // scope's sys_id, so resolve it back to the scope name the file is keyed on.
+        const scopeName = args.scope || (await resolveScopeName(applicationScope));
+        if (scopeName) {
+            const routed = (0, updateSetConfig_1.writeUpdateSetRouting)({ scope: scopeName, sysId, name });
+            if (routed) {
+                Logger_1.logger.info(chalk_1.default.green(`✓ Push routing updated: ${scopeName} -> ${name} (${sysId})`));
+            }
+        }
+        else {
+            Logger_1.logger.warn("Could not resolve the scope name, so .dove-update-sets.json was not " +
+                "updated. `dove push` routes captures by scope via that file — pass " +
+                "--scope <scope> so pushes target this set.");
+        }
     }
     catch (e) {
         Logger_1.logger.error("Failed to switch update set");
@@ -489,6 +526,30 @@ async function getActiveUpdateSetName(client, scope) {
         return null;
     }
 }
+/**
+ * Resolves a scope's sys_id back to its scope name (e.g. "x_cadso_core"), used
+ * to key the .dove-update-sets.json push-routing entry. Returns undefined when
+ * the input is missing or the lookup fails so the caller can warn instead.
+ */
+async function resolveScopeName(applicationSysId) {
+    if (!applicationSysId || applicationSysId.trim() === "")
+        return undefined;
+    try {
+        const client = (0, snClient_1.defaultClient)();
+        const rows = await (0, snClient_1.unwrapSNResponse)(client.getScopeById(applicationSysId));
+        if (rows && rows.length > 0) {
+            const resolved = rows[0].scope;
+            if (resolved && typeof resolved === "string" && resolved.trim() !== "") {
+                return resolved;
+            }
+        }
+    }
+    catch (e) {
+        Logger_1.logger.debug("Could not resolve scope name from application sys_id: " +
+            (e instanceof Error ? e.message : String(e)));
+    }
+    return undefined;
+}
 /**
  * Helper function to switch to a scope
  */

package/dist/updateSetConfig.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readUpdateSetConfig = readUpdateSetConfig;
+exports.writeUpdateSetRouting = writeUpdateSetRouting;
+const fs_1 = __importDefault(require("fs"));
+const projectFiles_1 = require("./projectFiles");
+const Logger_1 = require("./Logger");
+/**
+ * Read .dove-update-sets.json (or its legacy .sinc- sibling). Returns {} when
+ * the file is absent or unparseable, so callers never have to guard for null.
+ */
+function readUpdateSetConfig() {
+    const configPath = (0, projectFiles_1.getUpdateSetsConfigPath)();
+    try {
+        if (fs_1.default.existsSync(configPath)) {
+            const parsed = JSON.parse(fs_1.default.readFileSync(configPath, "utf8"));
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                return parsed;
+            }
+            Logger_1.logger.warn(`Update set config at ${configPath} is not an object; ignoring it.`);
+        }
+    }
+    catch (e) {
+        Logger_1.logger.warn(`Failed to parse update set config at ${configPath}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    return {};
+}
+/**
+ * Merge a single scope's update set into .dove-update-sets.json so that
+ * `dove push` routes that scope's records to the set the operator just created
+ * or switched to.
+ *
+ * Without this, `dove createUpdateSet` / `dove switchUpdateSet` only flip the
+ * instance's *active* update set, while `dove push` keeps routing via this file
+ * — so a freshly "activated" set can stay empty and the work lands in whatever
+ * stale set the file still points at (TenonHQ/Dovetail#182).
+ *
+ * Returns the path written, or null when any input is missing (no scope name,
+ * sys_id, or set name to route by) so the caller can warn instead.
+ */
+function writeUpdateSetRouting(opts) {
+    const scope = opts.scope ? opts.scope.trim() : "";
+    const sysId = opts.sysId ? opts.sysId.trim() : "";
+    const name = opts.name ? opts.name.trim() : "";
+    if (!scope || !sysId || !name)
+        return null;
+    const configPath = (0, projectFiles_1.getUpdateSetsConfigPath)();
+    const config = readUpdateSetConfig();
+    config[scope] = { sys_id: sysId, name };
+    fs_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    return configPath;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tenonhq/dovetail-core",
-  "version": "0.0.106",
+  "version": "0.0.108",
   "description": "Next-gen file syncer",
   "license": "GPL-3.0",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
     "node": ">=22"
   },
   "devDependencies": {
-    "@tenonhq/dovetail-types": "~0.0.19",
+    "@tenonhq/dovetail-types": "~0.0.20",
     "@types/dotenv": "^6.1.1",
     "@types/inquirer": "^8.2.10",
     "@types/jest": "^29.5.5",
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "@tenonhq/dovetail-clickup": "~0.0.12",
-    "@tenonhq/dovetail-schema": "~0.0.11",
+    "@tenonhq/dovetail-schema": "~0.0.12",
     "axios": "^1.5.1",
     "axios-cookiejar-support": "^4.0.7",
     "axios-rate-limit": "^1.3.0",