@tenonhq/sincronia-core 0.0.78 → 0.0.80

package/README.md

@@ -1,4 +1,4 @@
-# @sincronia/core
+# @tenonhq/sincronia-core
 
 This module contains the core of Sincronia. It is required to use Sincronia at all.
 It can interact with other plugins after you configure them.

package/dist/FileUtils.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeFileForce = exports.writeSNFileForce = exports.writeSNFileIfNotExists = exports.writeBuildFile = exports.summarizeFile = exports.encodedPathsToFilePaths = exports.isValidPath = exports.splitEncodedPaths = exports.getPathsInPath = exports.isDirectory = exports.toAbsolutePath = exports.getFileContextFromPath = exports.getBuildExt = exports.isUnderPath = exports.appendToPath = exports.pathExists = exports.createDirRecursively = exports.writeSNFileCurry = exports.writeScopeManifest = exports.writeManifestFile = exports.SNFileExists = void 0;
+exports.writeFileForce = exports.writeSNFileForce = exports.writeSNFileIfNotExists = exports.writeBuildFile = exports.summarizeFile = exports.encodedPathsToFilePaths = exports.isValidPath = exports.splitEncodedPaths = exports.getPathsInPath = exports.isDirectory = exports.toAbsolutePath = exports.getFileContextFromPath = exports.getFileContextWithSkipReason = exports.getBuildExt = exports.isUnderPath = exports.appendToPath = exports.pathExists = exports.createDirRecursively = exports.writeSNFileCurry = exports.writeScopeManifest = exports.writeManifestFile = exports.SNFileExists = void 0;
 exports.writeEnvVar = writeEnvVar;
 exports.writeEnvVars = writeEnvVars;
 const constants_1 = require("./constants");
@@ -164,7 +164,7 @@ const getTargetFieldFromPath = (filePath, table, ext) => {
         ? "inputs.script"
         : path_1.default.basename(filePath, ext);
 };
-const getFileContextFromPath = (filePath) => {
+const getFileContextWithSkipReason = (filePath) => {
     const ext = getFileExtension(filePath);
     const [tableName, recordName] = path_1.default
         .dirname(filePath)
@@ -180,11 +180,11 @@ const getFileContextFromPath = (filePath) => {
     if (ConfigManager.isMultiScopeManifest(manifest)) {
         var detectedScope = ConfigManager.resolveScopeFromPath(filePath);
         if (!detectedScope) {
-            return undefined;
+            return { skipReason: "scope not found" };
         }
         var scopeMan = ConfigManager.resolveManifestForScope(manifest, detectedScope);
         if (!scopeMan) {
-            return undefined;
+            return { skipReason: "scope manifest not found" };
         }
         scope = scopeMan.scope || detectedScope;
         tables = scopeMan.tables;
@@ -199,22 +199,28 @@ const getFileContextFromPath = (filePath) => {
         const { files, sys_id } = record;
         const field = files.find((file) => file.name === targetField);
         if (!field) {
-            return undefined;
+            return { skipReason: "not in manifest" };
         }
         return {
-            filePath,
-            ext,
-            sys_id,
-            name: recordName,
-            scope,
-            tableName,
-            targetField,
+            context: {
+                filePath,
+                ext,
+                sys_id,
+                name: recordName,
+                scope,
+                tableName,
+                targetField,
+            },
         };
     }
     catch (e) {
-        return undefined;
+        return { skipReason: "not in manifest" };
     }
 };
+exports.getFileContextWithSkipReason = getFileContextWithSkipReason;
+const getFileContextFromPath = (filePath) => {
+    return (0, exports.getFileContextWithSkipReason)(filePath).context;
+};
 exports.getFileContextFromPath = getFileContextFromPath;
 const toAbsolutePath = (p) => path_1.default.isAbsolute(p) ? p : path_1.default.join(process.cwd(), p);
 exports.toAbsolutePath = toAbsolutePath;

package/dist/MultiScopeWatcher.js

@@ -54,7 +54,11 @@ class MultiScopeWatcherManager {
     scopeWatchers = new Map();
     updateSetCheckInterval = null;
     scopeLock = Promise.resolve();
-    async startWatchingAllScopes() {
+    cachedScope = null;
+    pendingScopes = new Map(); // scope -> first change timestamp
+    globalProcessQueue = null;
+    async startWatchingAllScopes(options) {
+        var opts = options || { monitorIntervalMs: 120000 };
         try {
             // Load configuration
             await ConfigManager.loadConfigs();
@@ -78,8 +82,13 @@ class MultiScopeWatcherManager {
                 }
                 this.startWatchingScope(scopeName, sourceDirectory);
             }
-            // Start periodic update set checking
-            this.startUpdateSetMonitoring();
+            // Start periodic update set checking (unless disabled)
+            if (opts.monitorIntervalMs > 0) {
+                this.startUpdateSetMonitoring(opts.monitorIntervalMs);
+            }
+            else {
+                Logger_1.logger.info("Update set monitoring disabled (--noMonitoring)");
+            }
             Logger_1.logger.success("✅ Multi-scope watch started successfully!");
             Logger_1.logger.info("Watching for file changes across all scopes...");
             Logger_1.logger.info("Press Ctrl+C to stop watching\n");
@@ -105,19 +114,27 @@ class MultiScopeWatcherManager {
             pushQueue: [],
             sourceDirectory: sourceDirectory
         };
-        // Create a debounced processor for this scope
-        const processQueue = (0, lodash_1.debounce)(async () => {
-            await this.processScopeQueue(scopeWatcher);
-        }, DEBOUNCE_MS);
+        // Initialize global debounce once (shared across all scopes)
+        if (!this.globalProcessQueue) {
+            this.globalProcessQueue = (0, lodash_1.debounce)(async () => {
+                await this.processAllPendingScopes();
+            }, DEBOUNCE_MS);
+        }
         watcher.on("change", (filePath) => {
             Logger_1.logger.info(`[${scopeName}] File changed: ${path.relative(sourceDirectory, filePath)}`);
             scopeWatcher.pushQueue.push(filePath);
-            processQueue();
+            if (!this.pendingScopes.has(scopeName)) {
+                this.pendingScopes.set(scopeName, Date.now());
+            }
+            this.globalProcessQueue();
         });
         watcher.on("add", (filePath) => {
             Logger_1.logger.info(`[${scopeName}] File added: ${path.relative(sourceDirectory, filePath)}`);
             scopeWatcher.pushQueue.push(filePath);
-            processQueue();
+            if (!this.pendingScopes.has(scopeName)) {
+                this.pendingScopes.set(scopeName, Date.now());
+            }
+            this.globalProcessQueue();
         });
         watcher.on("error", (error) => {
             Logger_1.logger.error(`[${scopeName}] Watcher error: ${error.message}`);
@@ -145,7 +162,7 @@ class MultiScopeWatcherManager {
             }
         }
         catch (e) {
-            // Ignore parse errors
+            Logger_1.logger.warn(`[MultiScope] Failed to parse update set config at ${configPath}: ${e instanceof Error ? e.message : String(e)}`);
         }
         return {};
     }
@@ -153,11 +170,27 @@ class MultiScopeWatcherManager {
         var taskPath = path.resolve(process.cwd(), ".sinc-active-task.json");
         try {
             if (fs.existsSync(taskPath)) {
-                return JSON.parse(fs.readFileSync(taskPath, "utf8"));
+                var parsed = JSON.parse(fs.readFileSync(taskPath, "utf8"));
+                if (!parsed.taskId || typeof parsed.taskId !== "string" || parsed.taskId.trim() === "") {
+                    Logger_1.logger.error("Active task file is missing a valid taskId. Ignoring active task.");
+                    return null;
+                }
+                if (!parsed.updateSetName || typeof parsed.updateSetName !== "string" || parsed.updateSetName.trim() === "") {
+                    Logger_1.logger.error("Active task file is missing a valid updateSetName. Ignoring active task.");
+                    return null;
+                }
+                var stat = fs.statSync(taskPath);
+                var ageMs = Date.now() - stat.mtimeMs;
+                var ageDays = Math.floor(ageMs / (1000 * 60 * 60 * 24));
+                if (ageDays >= 7) {
+                    var taskName = parsed.taskName || parsed.taskId;
+                    Logger_1.logger.warn("Active task " + taskName + " was selected " + ageDays + " days ago. Run sinc task clear if you have moved on.");
+                }
+                return parsed;
             }
         }
         catch (e) {
-            // Ignore parse errors
+            Logger_1.logger.warn(`Failed to parse active task file: ${e instanceof Error ? e.message : String(e)}`);
         }
         return null;
     }
@@ -172,12 +205,50 @@ class MultiScopeWatcherManager {
         }
         var activeTask = this.readActiveTask();
         if (!activeTask) {
-            Logger_1.logger.warn(`[${scopeName}] No update set configured and no active task to auto-create one. Pushing without update set routing.`);
+            // No active task — try to resolve the current update set from the ServiceNow
+            // session so pushWithUpdateSet can be used instead of the fallback updateRecord.
+            try {
+                var { defaultClient } = await Promise.resolve().then(() => __importStar(require("./snClient")));
+                var sessionClient = defaultClient();
+                var curResp = await sessionClient.getCurrentUpdateSet(scopeName);
+                var curData = curResp.data;
+                if (curData && curData.result) {
+                    curData = curData.result;
+                }
+                var curSysId = curData && curData.sysId ? curData.sysId : null;
+                var curName = curData && curData.name ? curData.name : null;
+                if (curSysId && curName) {
+                    var isDefault = curName === "Default" || curName.toLowerCase().indexOf("default") !== -1;
+                    if (isDefault) {
+                        Logger_1.logger.warn(`[${scopeName}] No update set configured and current update set is Default. ` +
+                            `Use sinc createUpdateSet or activate a task in the dashboard.`);
+                    }
+                    else {
+                        // Use the session's current non-Default update set
+                        config = this.getUpdateSetConfig();
+                        config[scopeName] = { sys_id: curSysId, name: curName };
+                        this.saveUpdateSetConfig(config);
+                        Logger_1.logger.info(`[${scopeName}] Using session update set: ${curName}`);
+                    }
+                }
+                else {
+                    Logger_1.logger.warn(`[${scopeName}] No update set configured for scope ${scopeName}. ` +
+                        `Use sinc createUpdateSet or activate a task in the dashboard.`);
+                }
+            }
+            catch (queryErr) {
+                Logger_1.logger.warn(`[${scopeName}] No update set configured and could not query current update set. ` +
+                    `Changes will use direct Table API. Use sinc createUpdateSet or activate a task in the dashboard.`);
+            }
             return;
         }
         var taskId = activeTask.taskId;
         var updateSetName = activeTask.updateSetName;
         var description = activeTask.description || "";
+        if (!taskId || taskId.trim() === "") {
+            Logger_1.logger.error(`[${scopeName}] Active task has an empty taskId. Skipping update set lookup.`);
+            return;
+        }
         Logger_1.logger.info(`[${scopeName}] No update set found — auto-creating for task CU-${taskId}...`);
         try {
             var { defaultClient, unwrapSNResponse } = await Promise.resolve().then(() => __importStar(require("./snClient")));
@@ -185,7 +256,11 @@ class MultiScopeWatcherManager {
             // Switch to the target scope and resolve its sys_id for update set creation
             await client.changeScope(scopeName);
             var scopeIdResult = await unwrapSNResponse(client.getScopeId(scopeName));
-            var scopeSysId = scopeIdResult.length > 0 ? scopeIdResult[0].sys_id : undefined;
+            var scopeSysId = scopeIdResult && scopeIdResult.length > 0 ? scopeIdResult[0].sys_id : undefined;
+            if (!scopeSysId) {
+                Logger_1.logger.error(`[${scopeName}] Scope "${scopeName}" not found on the instance. Cannot create update set for an invalid scope.`);
+                return;
+            }
             // Search for an existing update set matching this task in this scope
             var query = "application.scope=" + scopeName +
                 "^nameLIKECU-" + taskId +
@@ -210,17 +285,48 @@ class MultiScopeWatcherManager {
                 updateSet = { sys_id: createResp.sys_id, name: updateSetName };
                 Logger_1.logger.info(`[${scopeName}] Auto-created update set: ${updateSet.name}`);
             }
-            // Switch the active update set on the instance
+            // Switch the active update set on the instance and verify
             try {
                 await client.changeUpdateSet({ sysId: updateSet.sys_id });
+                // Verify the switch was successful
+                var verifyResp = await client.getCurrentUpdateSet(scopeName);
+                var verifyResult = verifyResp.data;
+                if (verifyResult && verifyResult.result) {
+                    verifyResult = verifyResult.result;
+                }
+                var currentSysId = verifyResult && verifyResult.sysId ? verifyResult.sysId : null;
+                if (currentSysId !== updateSet.sys_id) {
+                    // Retry once
+                    Logger_1.logger.warn(`[${scopeName}] Update set verification failed, retrying switch...`);
+                    await client.changeUpdateSet({ sysId: updateSet.sys_id });
+                    var retryResp = await client.getCurrentUpdateSet(scopeName);
+                    var retryResult = retryResp.data;
+                    if (retryResult && retryResult.result) {
+                        retryResult = retryResult.result;
+                    }
+                    var retrySysId = retryResult && retryResult.sysId ? retryResult.sysId : null;
+                    if (retrySysId !== updateSet.sys_id) {
+                        var actualName = retryResult && retryResult.name ? retryResult.name : "unknown";
+                        Logger_1.logger.error(`[${scopeName}] Update set ${updateSet.name} was created but could not be activated. Current update set is ${actualName}.`);
+                        throw new Error(`Update set ${updateSet.name} could not be activated for scope ${scopeName}`);
+                    }
+                }
+                Logger_1.logger.debug(`[${scopeName}] Update set switch verified: ${updateSet.name}`);
             }
             catch (changeErr) {
                 Logger_1.logger.warn(`[${scopeName}] Could not auto-switch update set on instance`);
             }
-            // Persist the mapping
+            // Persist the mapping (serialized under scopeLock — safe from concurrent writes)
             config = this.getUpdateSetConfig(); // Re-read in case another scope wrote
             config[scopeName] = { sys_id: updateSet.sys_id, name: updateSet.name };
             this.saveUpdateSetConfig(config);
+            // Verify the write persisted correctly
+            var verifiedConfig = this.getUpdateSetConfig();
+            if (!verifiedConfig[scopeName] || verifiedConfig[scopeName].sys_id !== updateSet.sys_id) {
+                Logger_1.logger.error(`[${scopeName}] Update set config write verification failed. Expected mapping for ${scopeName} with sys_id ${updateSet.sys_id} but got: ${JSON.stringify(verifiedConfig[scopeName])}`);
+                throw new Error(`Update set config write verification failed for scope ${scopeName}`);
+            }
+            Logger_1.logger.debug(`[${scopeName}] Update set config verified: ${updateSet.name} (${updateSet.sys_id})`);
             // Also update the active task file
             if (activeTask) {
                 if (!activeTask.scopes) {
@@ -236,6 +342,20 @@ class MultiScopeWatcherManager {
             Logger_1.logger.warn(`[${scopeName}] Pushing without update set routing.`);
         }
     }
+    async processAllPendingScopes() {
+        // Sort scopes by first file change timestamp (FIFO)
+        var sorted = Array.from(this.pendingScopes.entries()).sort(function (a, b) {
+            return a[1] - b[1];
+        });
+        this.pendingScopes.clear();
+        for (var i = 0; i < sorted.length; i++) {
+            var scopeName = sorted[i][0];
+            var scopeWatcher = this.scopeWatchers.get(scopeName);
+            if (scopeWatcher && scopeWatcher.pushQueue.length > 0) {
+                await this.processScopeQueue(scopeWatcher);
+            }
+        }
+    }
     async processScopeQueue(scopeWatcher) {
         if (scopeWatcher.pushQueue.length === 0)
             return;
@@ -250,12 +370,29 @@ class MultiScopeWatcherManager {
                 await this.ensureUpdateSetForScope(scopeWatcher.scope);
                 // Load the manifest for this specific scope
                 await this.loadScopeManifest(scopeWatcher.scope, scopeWatcher.sourceDirectory);
-                // Process the files
-                const fileContexts = toProcess
-                    .map(FileUtils_1.getFileContextFromPath)
-                    .filter((ctx) => !!ctx);
+                // Process the files — track skip reasons for summary
+                const fileContexts = [];
+                const skippedFiles = [];
+                toProcess.forEach(function (filePath) {
+                    var result = (0, FileUtils_1.getFileContextWithSkipReason)(filePath);
+                    if (result.context) {
+                        // Scope validation: ensure the record's scope matches the watcher's scope
+                        if (result.context.scope && result.context.scope !== scopeWatcher.scope) {
+                            Logger_1.logger.error(`[${scopeWatcher.scope}] Scope mismatch: ${filePath} belongs to scope "${result.context.scope}" but was queued by watcher for "${scopeWatcher.scope}". Skipping to prevent cross-scope contamination.`);
+                            skippedFiles.push({ filePath: filePath, reason: `scope mismatch (record: ${result.context.scope}, watcher: ${scopeWatcher.scope})` });
+                        }
+                        else {
+                            fileContexts.push(result.context);
+                        }
+                    }
+                    else {
+                        var reason = result.skipReason || "unknown";
+                        Logger_1.logger.warn(`[${scopeWatcher.scope}] Skipped: ${filePath} (${reason})`);
+                        skippedFiles.push({ filePath: filePath, reason: reason });
+                    }
+                });
                 if (fileContexts.length === 0) {
-                    Logger_1.logger.warn(`[${scopeWatcher.scope}] No valid file contexts found`);
+                    Logger_1.logger.warn(`[${scopeWatcher.scope}] No valid file contexts found. ${skippedFiles.length} file(s) skipped.`);
                     return;
                 }
                 const buildables = (0, appUtils_1.groupAppFiles)(fileContexts);
@@ -268,7 +405,15 @@ class MultiScopeWatcherManager {
                         }
                     }
                 });
-                Logger_1.logger.success(`[${scopeWatcher.scope}] Successfully pushed ${updateResults.length} file(s)`);
+                // Push summary
+                var pushedCount = updateResults.filter(function (r) { return r.success; }).length;
+                var totalCount = toProcess.length;
+                var summaryParts = [`Pushed ${pushedCount}/${totalCount} files to ${scopeWatcher.scope}.`];
+                if (skippedFiles.length > 0) {
+                    var skippedList = skippedFiles.map(function (s) { return `${s.filePath} (${s.reason})`; }).join(", ");
+                    summaryParts.push(`${skippedFiles.length} files skipped: [${skippedList}]`);
+                }
+                Logger_1.logger.info(`[${scopeWatcher.scope}] ${summaryParts.join(" ")}`);
             });
         }
         catch (error) {
@@ -332,91 +477,68 @@ class MultiScopeWatcherManager {
         }
     }
     async switchToScope(scopeName) {
+        // Skip if already on the correct scope
+        if (this.cachedScope === scopeName) {
+            Logger_1.logger.debug(`Already on scope ${scopeName}, skipping switch`);
+            return;
+        }
         try {
-            const { defaultClient, unwrapSNResponse } = await Promise.resolve().then(() => __importStar(require("./snClient")));
-            const client = defaultClient();
-            // Get the scope ID
-            const scopeResponse = await unwrapSNResponse(client.getScopeId(scopeName));
-            if (!scopeResponse || !Array.isArray(scopeResponse) || scopeResponse.length === 0 || !scopeResponse[0].sys_id) {
-                throw new Error(`Scope ${scopeName} not found`);
-            }
-            // Get user sys_id
-            const userResponse = await unwrapSNResponse(client.getUserSysId());
-            if (!userResponse || !Array.isArray(userResponse) || userResponse.length === 0 || !userResponse[0].sys_id) {
-                throw new Error("Could not get user sys_id");
-            }
-            // Get current app preference
-            const prefResponse = await unwrapSNResponse(client.getCurrentAppUserPrefSysId(userResponse[0].sys_id));
-            if (prefResponse && Array.isArray(prefResponse) && prefResponse.length > 0 && prefResponse[0].sys_id) {
-                // Update existing preference
-                await client.updateCurrentAppUserPref(scopeResponse[0].sys_id, prefResponse[0].sys_id);
-            }
-            else {
-                // Create new preference
-                await client.createCurrentAppUserPref(scopeResponse[0].sys_id, userResponse[0].sys_id);
-            }
+            var { defaultClient } = await Promise.resolve().then(() => __importStar(require("./snClient")));
+            var client = defaultClient();
+            // Use the Claude REST API changeScope endpoint to switch the session scope.
+            // This uses gs.setCurrentApplicationId() server-side, which correctly changes
+            // the REST API session scope. The previous approach used user preference updates
+            // (apps.current_app) which only writes a DB record and does NOT affect the
+            // active REST session — causing updateRecord() to operate in the wrong scope.
+            await client.changeScope(scopeName);
+            this.cachedScope = scopeName;
             Logger_1.logger.debug(`Switched to scope: ${scopeName}`);
         }
         catch (error) {
+            // Invalidate cache on failure
+            this.cachedScope = null;
             Logger_1.logger.error(`Failed to switch to scope ${scopeName}: ${error}`);
             throw error;
         }
     }
-    async startUpdateSetMonitoring() {
+    async startUpdateSetMonitoring(intervalMs) {
         // Check update sets immediately on start
         await this.checkAllUpdateSets();
-        // Then check every 2 minutes
+        Logger_1.logger.info("Update set monitoring interval: " + Math.round(intervalMs / 1000) + "s");
         this.updateSetCheckInterval = setInterval(async () => {
             await this.checkAllUpdateSets();
-        }, 120000); // 2 minutes = 120000ms
+        }, intervalMs);
     }
     async checkAllUpdateSets() {
+        // Budget: monitoring should not consume more than 5% of the 20 RPS rate limit
+        // per cycle. That gives us ~1 request/second budget. Each scope check uses
+        // ~6 API calls (switchToScope ~3, getUserSysId ~1, pref ~1, details ~1).
+        // To stay within budget we use the local update set config file instead of
+        // querying ServiceNow for each scope — 0 API calls when config is present.
         try {
-            const { defaultClient, unwrapSNResponse } = await Promise.resolve().then(() => __importStar(require("./snClient")));
-            const client = defaultClient();
             const config = ConfigManager.getConfig();
             if (!config.scopes)
                 return;
             const scopes = Object.keys(config.scopes);
+            var updateSetConfig = this.getUpdateSetConfig();
             Logger_1.logger.info("\n" + "=".repeat(60));
             Logger_1.logger.info("Update Set Status Check");
             Logger_1.logger.info("=".repeat(60));
-            for (const scopeName of scopes) {
-                try {
-                    // Switch to scope to check its update set
-                    await this.switchToScope(scopeName);
-                    // Get user sys_id
-                    const userResponse = await unwrapSNResponse(client.getUserSysId());
-                    if (!userResponse || !Array.isArray(userResponse) || userResponse.length === 0 || !userResponse[0].sys_id) {
-                        Logger_1.logger.warn(`[${scopeName}] Could not get user information`);
-                        continue;
-                    }
-                    // Get current update set preference
-                    const updateSetPref = await unwrapSNResponse(client.getCurrentUpdateSetUserPref(userResponse[0].sys_id));
-                    if (updateSetPref && Array.isArray(updateSetPref) && updateSetPref.length > 0 && updateSetPref[0].value) {
-                        // Get update set details
-                        const updateSetId = updateSetPref[0].value;
-                        const updateSetDetails = await this.getUpdateSetDetails(updateSetId);
-                        if (updateSetDetails) {
-                            const isDefault = updateSetDetails.name === "Default" ||
-                                updateSetDetails.name.toLowerCase().includes("default");
-                            if (isDefault) {
-                                Logger_1.logger.warn(`⚠️  [${scopeName}] Currently in DEFAULT update set!`);
-                            }
-                            else {
-                                Logger_1.logger.info(`✅ [${scopeName}] Update Set: ${updateSetDetails.name}`);
-                            }
-                        }
-                        else {
-                            Logger_1.logger.info(`[${scopeName}] Update Set ID: ${updateSetId}`);
-                        }
+            for (var i = 0; i < scopes.length; i++) {
+                var scopeName = scopes[i];
+                var mapping = updateSetConfig[scopeName];
+                if (mapping && mapping.name) {
+                    var isDefault = mapping.name === "Default" ||
+                        mapping.name.toLowerCase().indexOf("default") !== -1;
+                    if (isDefault) {
+                        Logger_1.logger.warn(`⚠️  [${scopeName}] Currently in DEFAULT update set!`);
                     }
                     else {
-                        Logger_1.logger.warn(`⚠️  [${scopeName}] No update set selected or in DEFAULT`);
+                        Logger_1.logger.info(`✅ [${scopeName}] Update Set: ${mapping.name}`);
                     }
                 }
-                catch (error) {
-                    Logger_1.logger.error(`[${scopeName}] Error checking update set: ${error}`);
+                else {
+                    Logger_1.logger.warn(`⚠️  [${scopeName}] No update set configured`);
                 }
             }
             Logger_1.logger.info("=".repeat(60) + "\n");
@@ -450,7 +572,7 @@ class MultiScopeWatcherManager {
             return null;
         }
         catch (error) {
-            Logger_1.logger.debug(`Could not get update set details: ${error}`);
+            Logger_1.logger.warn(`Could not get update set details: ${error}`);
             return null;
         }
     }
@@ -461,6 +583,12 @@ class MultiScopeWatcherManager {
             scopeWatcher.watcher.close();
         }
         this.scopeWatchers.clear();
+        // Cancel global debounce
+        if (this.globalProcessQueue) {
+            this.globalProcessQueue.cancel();
+            this.globalProcessQueue = null;
+        }
+        this.pendingScopes.clear();
         // Stop update set monitoring
         if (this.updateSetCheckInterval) {
             clearInterval(this.updateSetCheckInterval);
@@ -470,8 +598,8 @@ class MultiScopeWatcherManager {
     }
 }
 exports.multiScopeWatcher = new MultiScopeWatcherManager();
-function startMultiScopeWatching() {
-    return exports.multiScopeWatcher.startWatchingAllScopes();
+function startMultiScopeWatching(options) {
+    return exports.multiScopeWatcher.startWatchingAllScopes(options);
 }
 function stopMultiScopeWatching() {
     exports.multiScopeWatcher.stopWatching();

package/dist/allScopesCommands.js

@@ -366,8 +366,10 @@ async function watchAllScopesCommand(args) {
         }
         // Import and start the multi-scope watcher
         const { startMultiScopeWatching } = await Promise.resolve().then(() => __importStar(require("./MultiScopeWatcher")));
-        // Start watching all scopes
-        await startMultiScopeWatching();
+        // Start watching all scopes with monitoring options
+        await startMultiScopeWatching({
+            monitorIntervalMs: args.noMonitoring ? 0 : (args.monitorInterval || 120) * 1000,
+        });
         // Keep the process running
         process.on("SIGINT", async () => {
             Logger_1.logger.info("\nStopping multi-scope watch...");

package/dist/appUtils.js

@@ -56,7 +56,7 @@ const getUpdateSetConfig = () => {
         }
     }
     catch (e) {
-        // Ignore parse errors
+        Logger_1.logger.warn(`Failed to parse update set config at ${configPath}: ${e instanceof Error ? e.message : String(e)}`);
     }
     return {};
 };
@@ -318,9 +318,22 @@ const getAppFileList = async (paths) => {
     const validPaths = typeof paths === "object"
         ? paths
         : await fUtils.encodedPathsToFilePaths(paths);
-    const appFileCtxs = validPaths
-        .map(fUtils.getFileContextFromPath)
-        .filter((maybeCtx) => !!maybeCtx);
+    const appFileCtxs = [];
+    validPaths.forEach(function (filePath) {
+        var result = fUtils.getFileContextWithSkipReason(filePath);
+        if (result.context) {
+            appFileCtxs.push(result.context);
+        }
+        else {
+            var reason = result.skipReason || "unknown";
+            if (reason === "not in manifest") {
+                Logger_1.logger.info(`Skipped: ${filePath} (${reason})`);
+            }
+            else {
+                Logger_1.logger.warn(`Skipped: ${filePath} (${reason})`);
+            }
+        }
+    });
     return (0, exports.groupAppFiles)(appFileCtxs);
 };
 exports.getAppFileList = getAppFileList;
@@ -349,21 +362,19 @@ const buildRec = async (rec) => {
         builtRec,
     };
 };
-const pushRec = async (client, table, sysId, builtRec, summary, scope) => {
+const pushRec = async (client, table, sysId, builtRec, summary, scope, updateSetConfig) => {
     const recSummary = summary ?? `${table} > ${sysId}`;
     try {
-        // Check if an update set is configured for this scope
-        const updateSetConfig = getUpdateSetConfig();
-        const updateSet = scope ? updateSetConfig[scope] : undefined;
+        // Use the batch-level config passed from pushFiles() to avoid re-reading per record
+        const config = updateSetConfig || {};
+        const updateSet = scope ? config[scope] : undefined;
         const pushFn = updateSet
             ? () => {
                 Logger_1.logger.debug(`Pushing ${recSummary} via update set: ${updateSet.name}`);
                 return client.pushWithUpdateSet(updateSet.sys_id, table, sysId, builtRec);
             }
             : () => client.updateRecord(table, sysId, builtRec);
-        const pushRes = await (0, snClient_1.retryOnErr)(pushFn, constants_1.PUSH_RETRY_LIMIT, constants_1.PUSH_RETRY_WAIT, (numTries) => {
-            Logger_1.logger.debug(`Failed to push ${recSummary}! Retrying with ${numTries} left...`);
-        });
+        const pushRes = await (0, snClient_1.retryOnHttpErr)(pushFn, recSummary);
         return (0, snClient_1.processPushResponse)(pushRes, recSummary);
     }
     catch (e) {
@@ -398,7 +409,7 @@ const pushFiles = async (recs) => {
             tick();
             return { success: false, message: `${recSummary} : ${buildRes.message}` };
         }
-        const pushRes = await pushRec(client, rec.table, rec.sysId, buildRes.builtRec, recSummary, scope);
+        const pushRes = await pushRec(client, rec.table, rec.sysId, buildRes.builtRec, recSummary, scope, updateSetConfig);
         tick();
         return pushRes;
     });

package/dist/commander.js

@@ -35,6 +35,16 @@ async function initCommands() {
                 type: "number",
                 describe: "Dashboard port (default: DASHBOARD_PORT env or 3456)",
             },
+            monitorInterval: {
+                type: "number",
+                default: 120,
+                describe: "Update set monitoring interval in seconds (default: 120)",
+            },
+            noMonitoring: {
+                type: "boolean",
+                default: false,
+                describe: "Disable background update set monitoring",
+            },
         });
         return cmdArgs;
     }, async (args) => {
@@ -411,6 +421,13 @@ async function initCommands() {
             .demandCommand(1, "Please specify a clickup subcommand");
     }, function () {
         /* subcommands handle execution */
+    })
+        .command("task", "Manage the active ClickUp task for update set routing", function (cmdArgs) {
+        return cmdArgs
+            .command("clear", "Clear the active task (removes .sinc-active-task.json)", sharedOptions, commands_1.taskClearCommand)
+            .demandCommand(1, "Please specify a task subcommand (e.g., clear)");
+    }, function () {
+        /* subcommands handle execution */
     })
         .help().argv;
 }