@tenonhq/sincronia-core 0.0.78 → 0.0.80

package/dist/tests/verifyUpdateSetSwitch.test.js

@@ -0,0 +1,277 @@
+"use strict";
+/**
+ * Tests for US-007: Verify update set is active after creation
+ *
+ * Validates:
+ * - After switchToUpdateSet(), getCurrentUpdateSet() is called to verify the sys_id matches
+ * - Verification failure triggers a retry
+ * - Retry failure produces explicit error with actual update set name
+ * - MultiScopeWatcher's ensureUpdateSetForScope() includes the same verification
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+// --- Mock setup (MultiScopeWatcher tests) ---
+var mockSNClient = {
+    getScopeId: jest.fn(),
+    getUserSysId: jest.fn(),
+    getCurrentAppUserPrefSysId: jest.fn(),
+    updateCurrentAppUserPref: jest.fn(),
+    createCurrentAppUserPref: jest.fn(),
+    changeScope: jest.fn().mockResolvedValue(undefined),
+    createUpdateSet: jest.fn(),
+    changeUpdateSet: jest.fn(),
+    getCurrentUpdateSet: jest.fn(),
+    client: {
+        get: jest.fn(),
+    },
+};
+jest.mock("../snClient", () => ({
+    defaultClient: jest.fn(() => mockSNClient),
+    unwrapSNResponse: jest.fn((val) => val),
+}));
+jest.mock("../FileUtils", () => ({
+    getFileContextFromPath: jest.fn(),
+    getFileContextWithSkipReason: jest.fn(),
+}));
+jest.mock("../appUtils", () => ({
+    groupAppFiles: jest.fn(),
+    pushFiles: jest.fn(),
+}));
+jest.mock("../logMessages", () => ({
+    logFilePush: jest.fn(),
+}));
+jest.mock("../recentEdits", () => ({
+    writeRecentEdit: jest.fn(),
+}));
+jest.mock("../Logger", () => ({
+    logger: {
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        success: jest.fn(),
+        getLogLevel: jest.fn().mockReturnValue("info"),
+    },
+}));
+jest.mock("../config", () => ({
+    loadConfigs: jest.fn().mockResolvedValue(undefined),
+    getConfig: jest.fn(),
+    getRootDir: jest.fn().mockReturnValue("/project"),
+    updateManifest: jest.fn(),
+    getManifest: jest.fn(),
+    getSourcePath: jest.fn().mockReturnValue("/project/src"),
+    getScopeManifestPath: jest.fn((scope) => `/project/sinc.manifest.${scope}.json`),
+    getManifestPath: jest.fn().mockReturnValue("/project/sinc.manifest.json"),
+}));
+var mockFsStore = {};
+jest.mock("fs", () => ({
+    existsSync: jest.fn((p) => {
+        return p in mockFsStore;
+    }),
+    readFileSync: jest.fn((p) => {
+        if (p in mockFsStore)
+            return mockFsStore[p];
+        throw new Error("ENOENT: " + p);
+    }),
+    writeFileSync: jest.fn((p, data) => {
+        mockFsStore[p] = data;
+    }),
+    statSync: jest.fn(() => ({ mtimeMs: Date.now() })),
+    promises: {
+        readFile: jest.fn(),
+        writeFile: jest.fn(),
+        readdir: jest.fn(),
+        mkdir: jest.fn(),
+        access: jest.fn(),
+        stat: jest.fn(),
+    },
+}));
+jest.mock("chokidar", () => ({
+    watch: jest.fn(() => ({
+        on: jest.fn().mockReturnThis(),
+        close: jest.fn(),
+    })),
+}));
+jest.mock("lodash", () => {
+    var actual = jest.requireActual("lodash");
+    return {
+        ...actual,
+        debounce: jest.fn((fn) => {
+            var wrapper = jest.fn();
+            wrapper.cancel = jest.fn();
+            wrapper.flush = jest.fn(() => fn());
+            return wrapper;
+        }),
+    };
+});
+jest.mock("axios", () => ({
+    default: {
+        create: jest.fn(() => ({
+            get: jest.fn().mockResolvedValue({ data: { result: null } }),
+        })),
+    },
+}));
+// --- Imports ---
+const Logger_1 = require("../Logger");
+const MultiScopeWatcher_1 = require("../MultiScopeWatcher");
+// --- Tests ---
+describe("US-007: Verify update set is active after creation", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFsStore = {};
+        // Default: scope switching succeeds
+        mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "scope_sys_id" }]);
+        mockSNClient.getUserSysId.mockResolvedValue([{ sys_id: "user_sys_id" }]);
+        mockSNClient.getCurrentAppUserPrefSysId.mockResolvedValue([{ sys_id: "pref_sys_id" }]);
+        mockSNClient.updateCurrentAppUserPref.mockResolvedValue({});
+        mockSNClient.createCurrentAppUserPref.mockResolvedValue({});
+    });
+    afterEach(() => {
+        (0, MultiScopeWatcher_1.stopMultiScopeWatching)();
+    });
+    it("verifies update set switch by calling getCurrentUpdateSet after changeUpdateSet", async () => {
+        // Setup: active task + no existing config
+        var taskPath = require("path").resolve(process.cwd(), ".sinc-active-task.json");
+        mockFsStore[taskPath] = JSON.stringify({
+            taskId: "abc123",
+            taskName: "Test Task",
+            taskDescription: "Test",
+            updateSetName: "CU-abc123 Test Task",
+            description: "Test update set",
+            taskUrl: "https://example.com",
+            scopes: {},
+        });
+        // Scope exists
+        mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "scope_sys_id" }]);
+        // Search returns existing update set
+        mockSNClient.client.get.mockResolvedValue({
+            data: { result: [{ sys_id: "us_123", name: "CU-abc123 Test Task" }] }
+        });
+        // changeUpdateSet succeeds
+        mockSNClient.changeUpdateSet.mockResolvedValue(undefined);
+        // getCurrentUpdateSet confirms the correct sys_id
+        mockSNClient.getCurrentUpdateSet.mockResolvedValue({
+            data: { result: { sysId: "us_123", name: "CU-abc123 Test Task" } }
+        });
+        await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_test_scope");
+        // changeUpdateSet was called
+        expect(mockSNClient.changeUpdateSet).toHaveBeenCalledWith({ sysId: "us_123" });
+        // getCurrentUpdateSet was called for verification
+        expect(mockSNClient.getCurrentUpdateSet).toHaveBeenCalledWith("x_test_scope");
+        // Verify debug confirmation logged
+        expect(Logger_1.logger.debug).toHaveBeenCalledWith(expect.stringContaining("Update set switch verified"));
+    });
+    it("retries switch when verification shows wrong update set, succeeds on retry", async () => {
+        var taskPath = require("path").resolve(process.cwd(), ".sinc-active-task.json");
+        mockFsStore[taskPath] = JSON.stringify({
+            taskId: "abc123",
+            taskName: "Test Task",
+            taskDescription: "Test",
+            updateSetName: "CU-abc123 Test Task",
+            description: "Test update set",
+            taskUrl: "https://example.com",
+            scopes: {},
+        });
+        mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "scope_sys_id" }]);
+        mockSNClient.client.get.mockResolvedValue({
+            data: { result: [{ sys_id: "us_123", name: "CU-abc123 Test Task" }] }
+        });
+        mockSNClient.changeUpdateSet.mockResolvedValue(undefined);
+        // First verification fails (wrong sys_id), second succeeds
+        mockSNClient.getCurrentUpdateSet
+            .mockResolvedValueOnce({
+            data: { result: { sysId: "wrong_us_id", name: "Default" } }
+        })
+            .mockResolvedValueOnce({
+            data: { result: { sysId: "us_123", name: "CU-abc123 Test Task" } }
+        });
+        await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_test_scope");
+        // changeUpdateSet called twice (initial + retry)
+        expect(mockSNClient.changeUpdateSet).toHaveBeenCalledTimes(2);
+        // Warning logged about retry
+        expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("verification failed, retrying"));
+        // Should succeed — no error about "could not be activated"
+        var errorCalls = Logger_1.logger.error.mock.calls.map(function (c) { return c[0]; });
+        var hasActivationError = errorCalls.some(function (msg) {
+            return typeof msg === "string" && msg.indexOf("could not be activated") !== -1;
+        });
+        expect(hasActivationError).toBe(false);
+    });
+    it("logs explicit error when both switch attempts fail verification", async () => {
+        var taskPath = require("path").resolve(process.cwd(), ".sinc-active-task.json");
+        mockFsStore[taskPath] = JSON.stringify({
+            taskId: "abc123",
+            taskName: "Test Task",
+            taskDescription: "Test",
+            updateSetName: "CU-abc123 Test Task",
+            description: "Test update set",
+            taskUrl: "https://example.com",
+            scopes: {},
+        });
+        mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "scope_sys_id" }]);
+        mockSNClient.client.get.mockResolvedValue({
+            data: { result: [{ sys_id: "us_123", name: "CU-abc123 Test Task" }] }
+        });
+        mockSNClient.changeUpdateSet.mockResolvedValue(undefined);
+        // Both verifications fail — always returns wrong sys_id
+        mockSNClient.getCurrentUpdateSet.mockResolvedValue({
+            data: { result: { sysId: "wrong_us_id", name: "Default" } }
+        });
+        await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_test_scope");
+        // changeUpdateSet called twice (initial + retry)
+        expect(mockSNClient.changeUpdateSet).toHaveBeenCalledTimes(2);
+        // Error message should include both the update set name and the actual active one
+        expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("could not be activated"));
+        expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("Default"));
+    });
+    it("does not retry when verification passes on first attempt", async () => {
+        var taskPath = require("path").resolve(process.cwd(), ".sinc-active-task.json");
+        mockFsStore[taskPath] = JSON.stringify({
+            taskId: "abc123",
+            taskName: "Test Task",
+            taskDescription: "Test",
+            updateSetName: "CU-abc123 Test Task",
+            description: "Test update set",
+            taskUrl: "https://example.com",
+            scopes: {},
+        });
+        mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "scope_sys_id" }]);
+        mockSNClient.client.get.mockResolvedValue({
+            data: { result: [{ sys_id: "us_123", name: "CU-abc123 Test Task" }] }
+        });
+        mockSNClient.changeUpdateSet.mockResolvedValue(undefined);
+        // Verification passes on first attempt
+        mockSNClient.getCurrentUpdateSet.mockResolvedValue({
+            data: { result: { sysId: "us_123", name: "CU-abc123 Test Task" } }
+        });
+        await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_test_scope");
+        // changeUpdateSet called only once
+        expect(mockSNClient.changeUpdateSet).toHaveBeenCalledTimes(1);
+        // getCurrentUpdateSet called once for verification
+        expect(mockSNClient.getCurrentUpdateSet).toHaveBeenCalledTimes(1);
+        // No retry warning
+        expect(Logger_1.logger.warn).not.toHaveBeenCalledWith(expect.stringContaining("verification failed, retrying"));
+    });
+    it("handles getCurrentUpdateSet throwing during verification gracefully", async () => {
+        var taskPath = require("path").resolve(process.cwd(), ".sinc-active-task.json");
+        mockFsStore[taskPath] = JSON.stringify({
+            taskId: "abc123",
+            taskName: "Test Task",
+            taskDescription: "Test",
+            updateSetName: "CU-abc123 Test Task",
+            description: "Test update set",
+            taskUrl: "https://example.com",
+            scopes: {},
+        });
+        mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "scope_sys_id" }]);
+        mockSNClient.client.get.mockResolvedValue({
+            data: { result: [{ sys_id: "us_123", name: "CU-abc123 Test Task" }] }
+        });
+        mockSNClient.changeUpdateSet.mockResolvedValue(undefined);
+        // getCurrentUpdateSet throws (network error etc.)
+        mockSNClient.getCurrentUpdateSet.mockRejectedValue(new Error("Network error"));
+        // Should not crash — the outer try/catch in ensureUpdateSetForScope handles it
+        await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_test_scope");
+        // Should have attempted verification
+        expect(mockSNClient.getCurrentUpdateSet).toHaveBeenCalled();
+    });
+});

package/dist/updateSetCommands.js

@@ -226,7 +226,7 @@ async function createUpdateSetCommand(args) {
             Logger_1.logger.warn(`Update set "${name}" created but could not be activated automatically`);
             Logger_1.logger.info(`You can manually switch to it using: npx sinc switchUpdateSet --name "${name}"`);
             if (switchError instanceof Error) {
-                Logger_1.logger.debug(`Switch error: ${switchError.message}`);
+                Logger_1.logger.warn(`Switch error: ${switchError.message}`);
             }
         }
         Logger_1.logger.info(`Update Set ID: ${updateSetSysId}`);
@@ -400,7 +400,8 @@ async function promptForUpdateSetDetails(args) {
     };
 }
 /**
- * Helper function to switch to an update set using the new API endpoint
+ * Helper function to switch to an update set using the new API endpoint.
+ * Verifies the switch was successful by reading back the current update set.
  */
 async function switchToUpdateSet(updateSetSysId, name, scope) {
     const client = (0, snClient_1.defaultClient)();
@@ -431,6 +432,62 @@ async function switchToUpdateSet(updateSetSysId, name, scope) {
     if (result.message && !result.message.includes("Success") && !result.message.includes("changed")) {
         throw new Error(result.message);
     }
+    // Verify the switch was successful
+    var verified = await verifyActiveUpdateSet(client, updateSetSysId, scope);
+    if (!verified) {
+        // Retry once
+        Logger_1.logger.warn("Update set verification failed, retrying switch...");
+        var retryResponse = await client.changeUpdateSet(params);
+        var retryResult = await retryResponse.data;
+        if (retryResult && retryResult.result) {
+            retryResult = retryResult.result;
+        }
+        if (retryResult.error) {
+            throw new Error(retryResult.error);
+        }
+        var retryVerified = await verifyActiveUpdateSet(client, updateSetSysId, scope);
+        if (!retryVerified) {
+            var currentName = await getActiveUpdateSetName(client, scope);
+            throw new Error("Update set " + (name || updateSetSysId) + " was created but could not be activated. Current update set is " + (currentName || "unknown") + ".");
+        }
+    }
+}
+/**
+ * Verifies the currently active update set matches the expected sys_id.
+ */
+async function verifyActiveUpdateSet(client, expectedSysId, scope) {
+    try {
+        var response = await client.getCurrentUpdateSet(scope);
+        var result = await response.data;
+        if (result && result.result) {
+            result = result.result;
+        }
+        if (result && result.sysId === expectedSysId) {
+            return true;
+        }
+        Logger_1.logger.warn("Verification mismatch: expected " + expectedSysId + ", got " + (result && result.sysId ? result.sysId : "null"));
+        return false;
+    }
+    catch (e) {
+        Logger_1.logger.warn("Verification check failed: " + (e instanceof Error ? e.message : String(e)));
+        return false;
+    }
+}
+/**
+ * Gets the name of the currently active update set for error messages.
+ */
+async function getActiveUpdateSetName(client, scope) {
+    try {
+        var response = await client.getCurrentUpdateSet(scope);
+        var result = await response.data;
+        if (result && result.result) {
+            result = result.result;
+        }
+        return (result && result.name) ? result.name : null;
+    }
+    catch (e) {
+        return null;
+    }
 }
 /**
  * Helper function to switch to a scope

package/package.json

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

package/skills/sinc-configure-pipeline.md

@@ -44,19 +44,19 @@ For each file type, construct a rule using these templates:
   match: /\.ts$/,
   plugins: [
     {
-      name: "@sincronia/typescript-plugin",
+      name: "@tenonhq/sincronia-typescript-plugin",
       options: { transpile: false }
     },
     {
-      name: "@sincronia/babel-plugin",
+      name: "@tenonhq/sincronia-babel-plugin",
       options: {
         presets: [
-          "@sincronia/servicenow",
+          "@tenonhq/sincronia-servicenow",
           "@babel/env",
           "@babel/typescript"
         ],
         plugins: [
-          "@sincronia/remove-modules",
+          "@tenonhq/sincronia-remove-modules",
           "@babel/proposal-class-properties",
           "@babel/proposal-object-rest-spread"
         ]
@@ -72,14 +72,14 @@ For each file type, construct a rule using these templates:
   match: /\.js$/,
   plugins: [
     {
-      name: "@sincronia/babel-plugin",
+      name: "@tenonhq/sincronia-babel-plugin",
       options: {
         presets: [
-          "@sincronia/servicenow",
+          "@tenonhq/sincronia-servicenow",
           "@babel/env"
         ],
         plugins: [
-          "@sincronia/remove-modules"
+          "@tenonhq/sincronia-remove-modules"
         ]
       }
     }
@@ -93,7 +93,7 @@ For each file type, construct a rule using these templates:
   match: /\.wp\.js$/,
   plugins: [
     {
-      name: "@sincronia/webpack-plugin",
+      name: "@tenonhq/sincronia-webpack-plugin",
       options: {
         configGenerator: (context) => ({
           mode: "production",
@@ -110,7 +110,7 @@ For each file type, construct a rule using these templates:
 {
   match: /\.scss$/,
   plugins: [
-    { name: "@sincronia/sass-plugin", options: {} }
+    { name: "@tenonhq/sincronia-sass-plugin", options: {} }
   ]
 }
 ```
@@ -135,24 +135,24 @@ Provide a single `npm i -D` command with all required packages.
 
 | Plugin | Purpose | npm Package |
 |--------|---------|-------------|
-| TypeScript | Type-check and/or transpile `.ts` | `@sincronia/typescript-plugin` |
-| Babel | Run Babel transforms | `@sincronia/babel-plugin` |
-| ESLint | Lint before sync (blocks on errors) | `@sincronia/eslint-plugin` |
-| Prettier | Format output code | `@sincronia/prettier-plugin` |
-| SASS | Compile SCSS to CSS | `@sincronia/sass-plugin` |
-| Webpack | Bundle frontend JS | `@sincronia/webpack-plugin` |
+| TypeScript | Type-check and/or transpile `.ts` | `@tenonhq/sincronia-typescript-plugin` |
+| Babel | Run Babel transforms | `@tenonhq/sincronia-babel-plugin` |
+| ESLint | Lint before sync (blocks on errors) | `@tenonhq/sincronia-eslint-plugin` |
+| Prettier | Format output code | `@tenonhq/sincronia-prettier-plugin` |
+| SASS | Compile SCSS to CSS | `@tenonhq/sincronia-sass-plugin` |
+| Webpack | Bundle frontend JS | `@tenonhq/sincronia-webpack-plugin` |
 
 ### Babel Sub-Packages (used inside babel-plugin options)
 
 | Package | Purpose | Config Key |
 |---------|---------|------------|
-| `@sincronia/babel-plugin-remove-modules` | Strip import/export for ServiceNow | `plugins: ["@sincronia/remove-modules"]` |
-| `@sincronia/babel-preset-servicenow` | Sanitize for Rhino engine | `presets: ["@sincronia/servicenow"]` |
+| `@tenonhq/sincronia-babel-plugin-remove-modules` | Strip import/export for ServiceNow | `plugins: ["@tenonhq/sincronia-remove-modules"]` |
+| `@tenonhq/sincronia-babel-preset-servicenow` | Sanitize for Rhino engine | `presets: ["@tenonhq/sincronia-servicenow"]` |
 
 ### Critical Warnings
 
 - **Never use `useBuiltIns`** with `@babel/env` -- ServiceNow's Rhino engine locks base class prototypes, so polyfills will fail.
-- **Always include `@sincronia/servicenow`** as the FIRST Babel preset listed (runs last) for server-side code -- it handles `__proto__` and reserved word issues.
-- **Always include `@sincronia/remove-modules`** as a Babel plugin for server-side code -- ServiceNow does not support ES modules.
+- **Always include `@tenonhq/sincronia-servicenow`** as the FIRST Babel preset listed (runs last) for server-side code -- it handles `__proto__` and reserved word issues.
+- **Always include `@tenonhq/sincronia-remove-modules`** as a Babel plugin for server-side code -- ServiceNow does not support ES modules.
 - If using TypeScript plugin for type-checking only (`transpile: false`), Babel must handle the actual transpilation.
 - Webpack rules MUST come before generic `.js` rules in the rules array.

package/skills/sinc-debug-build.md

@@ -54,27 +54,27 @@ For a typical TypeScript server-side pipeline (`typescript-plugin` + `babel-plug
 **Stage 2: Babel Plugin** (with presets and plugins)
 
 Babel plugins run first (in order):
-1. `@sincronia/remove-modules` -- Strips `import`/`export` statements
+1. `@tenonhq/sincronia-remove-modules` -- Strips `import`/`export` statements
 2. `@babel/proposal-class-properties` -- Transforms class property syntax
 3. `@babel/proposal-object-rest-spread` -- Transforms `...spread` syntax
 
 Babel presets run in reverse order:
 1. `@babel/typescript` (listed last, runs first) -- Strips type annotations
 2. `@babel/env` -- Transpiles ES6+ to ES5
-3. `@sincronia/servicenow` (listed first, runs last) -- Sanitizes for Rhino: replaces `__proto__` with `__proto_sn__`, converts `obj.default` to `obj["default"]`
+3. `@tenonhq/sincronia-servicenow` (listed first, runs last) -- Sanitizes for Rhino: replaces `__proto__` with `__proto_sn__`, converts `obj.default` to `obj["default"]`
 
 ### Step 4: Diagnose Common Issues
 
 **"Cannot read property 'X' of undefined" in ServiceNow**
-- Likely: `import` statements were not removed. Check that `@sincronia/remove-modules` is in Babel plugins.
+- Likely: `import` statements were not removed. Check that `@tenonhq/sincronia-remove-modules` is in Babel plugins.
 - The import variable becomes `undefined` because ServiceNow has no module system.
 
 **"Illegal access to reserved word" in ServiceNow**
-- Likely: Missing `@sincronia/servicenow` preset. Code like `obj.default` or `obj.class` crashes Rhino.
-- Fix: Ensure `@sincronia/servicenow` is the FIRST preset listed (= runs LAST).
+- Likely: Missing `@tenonhq/sincronia-servicenow` preset. Code like `obj.default` or `obj.class` crashes Rhino.
+- Fix: Ensure `@tenonhq/sincronia-servicenow` is the FIRST preset listed (= runs LAST).
 
 **"__proto__" security error in ServiceNow**
-- Likely: Missing `@sincronia/servicenow` preset. Babel's class transpilation generates `__proto__` references.
+- Likely: Missing `@tenonhq/sincronia-servicenow` preset. Babel's class transpilation generates `__proto__` references.
 
 **"TypeError: Cannot extend a non-class" or prototype errors**
 - Likely: Using `useBuiltIns` with `@babel/env`. Rhino locks base class prototypes.
@@ -85,7 +85,7 @@ Babel presets run in reverse order:
 
 ### Special Comment Tags
 
-The `@sincronia/remove-modules` Babel plugin supports these comment tags:
+The `@tenonhq/sincronia-remove-modules` Babel plugin supports these comment tags:
 
 **`@keepModule`** -- Preserve an import (for actual ServiceNow modules):
 ```javascript

package/skills/sinc-setup-project.md

@@ -28,14 +28,14 @@ Help the user set up a new Sincronia project or add a new scope to an existing p
 ### Scenario 1: New Project
 
 #### Prerequisites check
-- Node.js v16+ installed (`node -v`)
+- Node.js v20 LTS installed (`node -v`)
 - The Sincronia server scoped app is installed on the target ServiceNow instance
 
 #### Initialize the project
 ```bash
 mkdir my-servicenow-app && cd my-servicenow-app
 npm init -y
-npm i -D @sincronia/core
+npm i -D @tenonhq/sincronia-core
 ```
 
 #### Run the init wizard

package/skills/sinc-troubleshoot-sync.md

@@ -68,16 +68,16 @@ Sincronia checks that your local manifest scope matches the active scope on the
 
 1. **Run a local build to see errors:** `npx sinc build`
 2. **Common Babel errors:**
-   - "Cannot find module '@sincronia/remove-modules'" -- Need `npm i -D @sincronia/babel-plugin-remove-modules`
-   - "Cannot find module '@sincronia/servicenow'" -- Need `npm i -D @sincronia/babel-preset-servicenow`
-   - Note: Babel package names differ from sinc.config.js names. In Babel config, `@sincronia/remove-modules` refers to npm package `@sincronia/babel-plugin-remove-modules`.
+   - "Cannot find module '@tenonhq/sincronia-remove-modules'" -- Need `npm i -D @tenonhq/sincronia-babel-plugin-remove-modules`
+   - "Cannot find module '@tenonhq/sincronia-servicenow'" -- Need `npm i -D @tenonhq/sincronia-babel-preset-servicenow`
+   - Note: Babel package names differ from sinc.config.js names. In Babel config, `@tenonhq/sincronia-remove-modules` refers to npm package `@tenonhq/sincronia-babel-plugin-remove-modules`.
 
 3. **Common TypeScript errors:**
    - Type errors block the build. Fix the types or set `transpile: true` to skip type checking.
    - Missing `tsconfig.json` -- Plugin works without it but may produce unexpected output.
 
 4. **Rhino engine errors (code works locally but fails in ServiceNow):**
-   - Missing `@sincronia/servicenow` preset -- `__proto__` references and reserved word property access crash Rhino.
+   - Missing `@tenonhq/sincronia-servicenow` preset -- `__proto__` references and reserved word property access crash Rhino.
    - Using `useBuiltIns` with `@babel/env` -- Polyfills fail because Rhino locks base class prototypes.
    - Using `for...of`, `Map`, `Set`, `WeakMap` -- These require prototype extensions that Rhino blocks.
    - Using arrow functions in class properties without `@babel/proposal-class-properties`.
@@ -110,4 +110,4 @@ Sincronia checks that your local manifest scope matches the active scope on the
 - Always `npx sinc refresh` before starting work to catch new records.
 - Use `npx sinc status` to verify connectivity.
 - Check `sincronia-debug-*.log` for detailed error information.
-- Node.js v16.x is required -- check with `node -v`.
+- Node.js v20 LTS is required -- check with `node -v`.