@omega.js/desktop 0.52.0 → 0.54.0

package/dist/test/suites/boot/consumer-app-boots.test.js

@@ -1,8 +1,8 @@
-// Boot-layer self-test — @omega.js/desktop's analog of "does the extension load?" (BXM) / "does the
-// site boot?" (UJM). The boot runner esbuild-builds the bundled fixture consumer
+// Boot-layer self-test — @omega.js/desktop's analog of "does the extension load?" /
+// "does the site boot?". The boot runner esbuild-builds the bundled fixture consumer
 // (src/test/fixtures/consumer-app) into a real main.bundle.js, spawns Electron with
 // it (the actual production boot path — bundled, not the unbundled lib code that the
-// `main` layer exercises), then runs these inspects against the live manager.
+// `main` layer exercises), then runs these inspects against the live omega instance.
 //
 // In @omega.js/desktop's own test run, OMEGA_TEST_BOOT_PROJECT points at the fixture (auto-set in
 // src/commands/test.js when the cwd is the @omega.js/desktop repo). In a real consumer's
@@ -11,7 +11,7 @@
 // boot tests under <cwd>/test/boot/.
 //
 // NOTE: inspect bodies are serialized to the spawned Electron process — no closures over
-// module scope. `require`, `process`, and `Buffer` are injected; { manager, expect,
+// module scope. `require`, `process`, and `Buffer` are injected; { omega, expect,
 // projectRoot, appRoot, frameworkDistRoot, distSnapshotBefore } is the inspect argument
 // (projectRoot = the fixture root; appRoot = the staged target root holding the build).
 
@@ -24,25 +24,25 @@ module.exports = defineCases({
   timeout: 30000,
   tests: [
     {
-      description: 'manager initialized with all core libs wired',
-      inspect: async ({ manager, expect }) => {
-        expect(manager).toBeTruthy();
-        expect(manager._initialized).toBe(true);
-        for (const lib of ['storage', 'ipc', 'windows', 'tray', 'menu', 'contextMenu', 'omega']) {
-          expect(Boolean(manager[lib])).toBe(true);
+      description: 'omega initialized with all core libs wired',
+      inspect: async ({ omega, expect }) => {
+        expect(omega).toBeTruthy();
+        expect(omega._initialized).toBe(true);
+        for (const lib of ['storage', 'ipc', 'windows', 'tray', 'menu', 'contextMenu', 'auth']) {
+          expect(Boolean(omega[lib])).toBe(true);
         }
       },
     },
 
     {
       description: 'the fixture main.js created the main window and loaded the built view',
-      inspect: async ({ manager, expect }) => {
+      inspect: async ({ omega, expect }) => {
         const { BrowserWindow } = require('electron');
 
         // windows.create() runs inside the consumer's initialize().then(); poll for it.
         let url = '';
         for (let i = 0; i < 40; i++) {
-          const win = manager.windows.get('main') || BrowserWindow.getAllWindows()[0];
+          const win = omega.windows.get('main') || BrowserWindow.getAllWindows()[0];
           if (win && !win.isDestroyed()) {
             url = win.webContents.getURL();
             if (url.includes('/views/main/')) break;
@@ -50,23 +50,23 @@ module.exports = defineCases({
           await new Promise((resolve) => setTimeout(resolve, 100));
         }
 
-        expect(Boolean(manager.windows.get('main'))).toBe(true);
+        expect(Boolean(omega.windows.get('main'))).toBe(true);
         expect(url.includes('/views/main/')).toBe(true);
       },
     },
 
     {
       description: 'test stealth: app activation suppressed — dock hidden (macOS)',
-      inspect: async ({ manager, expect }) => {
+      inspect: async ({ omega, expect }) => {
         if (process.platform !== 'darwin') {
           return; // accessory activation policy / dock is macOS-only
         }
-        // Manager.initialize step 1a hides the dock under the stealth predicate,
+        // omega.initialize step 1a hides the dock under the stealth predicate,
         // so the spawned consumer app never activates and never steals keyboard
         // focus from the developer's editor.
         const { app } = require('electron');
         expect(app.dock.isVisible()).toBe(false);
-        expect(manager.isTesting()).toBe(true);
+        expect(omega.isTesting()).toBe(true);
       },
     },
 
@@ -83,8 +83,8 @@ module.exports = defineCases({
     {
       // #111 — the fixture's renderer entry imports the vendored app-shell
       // module through the `__main_assets__` alias. Its declarative contract
-      // showing up in the built bundle proves the whole chain: esbuild alias →
-      // @omega.js/desktop's vendored dist asset → its @omega.js/client import.
+      // showing up in the built bundle proves the chain: esbuild alias →
+      // @omega.js/desktop's vendored dist asset.
       description: 'renderer bundle carries the vendored app-shell module via __main_assets__',
       inspect: async ({ expect, appRoot }) => {
         const fs = require('fs');
@@ -105,12 +105,12 @@ module.exports = defineCases({
       // line the bridge logs next is out of reach here, because the fixture's
       // `cloud.config` is empty and this boot never initializes Firebase auth.)
       description: 'the booted app runs in the lane environment, not the one baked into its bundle (#925)',
-      inspect: async ({ manager, expect, projectRoot }) => {
+      inspect: async ({ omega, expect, projectRoot }) => {
         const fs = require('fs');
         const path = require('path');
 
-        expect(manager.isTesting()).toBe(true);
-        expect(manager.config.environment).toBe('production');   // the artifact IS a production build
+        expect(omega.isTesting()).toBe(true);
+        expect(omega.config.environment).toBe('production');   // the artifact IS a production build
 
         const log = fs.readFileSync(path.join(projectRoot, 'logs', 'runtime.log'), 'utf8');
         expect(log.includes('auth persistence: none (test mode)')).toBe(true);
@@ -118,11 +118,11 @@ module.exports = defineCases({
     },
 
     {
-      // #925: a page has no `process`, so its Manager reads the baked word. The
+      // #925: a page has no `process`, so its instance reads the baked word. The
       // preload hands the running one over on `window.desktop`, and the renderer
       // bootstrap applies it, so this window answers what main answers.
       description: 'the main window renderer answers the lane environment too (#925)',
-      inspect: async ({ manager, expect }) => {
+      inspect: async ({ omega, expect }) => {
         const { BrowserWindow } = require('electron');
 
         // The window is created in the consumer's initialize().then(), and its
@@ -131,10 +131,10 @@ module.exports = defineCases({
         let answer = null;
         let win = null;
         for (let i = 0; i < 40; i++) {
-          win = manager.windows.get('main') || BrowserWindow.getAllWindows()[0];
+          win = omega.windows.get('main') || BrowserWindow.getAllWindows()[0];
           if (win && !win.isDestroyed() && !win.webContents.isLoading()) {
             answer = await win.webContents.executeJavaScript(
-              'window.__omegaManager && window.__omegaManager.config ? window.__omegaManager.getEnvironment() : null',
+              'window.__omegaInstance && window.__omegaInstance.config.environment ? window.__omegaInstance.getEnvironment() : null',
             );
             if (answer) break;
           }
@@ -146,7 +146,38 @@ module.exports = defineCases({
 
         expect(baked).toBe('production');     // what the build baked
         expect(bridged).toBe('testing');      // what the preload read off the lane
-        expect(answer).toBe('testing');       // what the renderer's Manager answers
+        expect(answer).toBe('testing');       // what the renderer's instance answers
+      },
+    },
+
+    {
+      // The renderer builds `omega.shell` from ITSELF with the vendored app
+      // shell's createShell(omega), exactly as web builds it; the fixture binds
+      // the same export through the `__main_assets__` alias (#111).
+      description: 'the main window renderer carries omega.shell, built by createShell(omega)',
+      inspect: async ({ omega, expect }) => {
+        const { BrowserWindow } = require('electron');
+
+        let probe = null;
+        for (let i = 0; i < 40; i++) {
+          const win = omega.windows.get('main') || BrowserWindow.getAllWindows()[0];
+          if (win && !win.isDestroyed() && !win.webContents.isLoading()) {
+            probe = await win.webContents.executeJavaScript(`(() => {
+              const instance = window.__omegaInstance;
+              if (!instance || !instance.shell) return null;
+              return {
+                createShell: typeof window.__omegaCreateShell,
+                isCollapsed: typeof instance.shell.isCollapsed,
+                toggleOpen: typeof instance.shell.toggleOpen,
+                desktopIsBridge: instance.desktop === window.desktop,
+              };
+            })()`);
+            if (probe) break;
+          }
+          await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+
+        expect(probe).toEqual({ createShell: 'function', isCollapsed: 'function', toggleOpen: 'function', desktopIsBridge: true });
       },
     },
   ],

package/dist/test/suites/boot/restart-manager.test.js

@@ -16,8 +16,8 @@ module.exports = defineCases({
   tests: [
     {
       description: 'restartManager wired, bailed as testing, nothing scheduled',
-      inspect: async ({ manager, expect }) => {
-        const rm = manager.restartManager;
+      inspect: async ({ omega, expect }) => {
+        const rm = omega.restartManager;
         expect(Boolean(rm)).toBe(true);
         for (const fn of ['register', 'unregister', 'ensureInstalled', 'ensureRunning', 'getStatus', 'shutdown']) {
           expect(typeof rm[fn]).toBe('function');

package/dist/test/suites/boot/storage-bundled.test.js

@@ -40,19 +40,19 @@ module.exports = defineCases({
 
     {
       description: 'storage is a REAL store through the bundle (not the no-op fallback)',
-      inspect: async ({ manager, expect }) => {
+      inspect: async ({ omega, expect }) => {
         const fs = require('fs');
 
         // The no-op fallback leaves _store null → getPath() null and get() always default.
-        manager.storage.set('desktop:boot:storageProof', 'bundled');
-        expect(manager.storage.get('desktop:boot:storageProof')).toBe('bundled');
+        omega.storage.set('desktop:boot:storageProof', 'bundled');
+        expect(omega.storage.get('desktop:boot:storageProof')).toBe('bundled');
 
-        const storePath = manager.storage.getPath();
+        const storePath = omega.storage.getPath();
         expect(Boolean(storePath)).toBe(true);
         expect(storePath.endsWith('omega-storage.json')).toBe(true);
         expect(fs.existsSync(storePath)).toBe(true);
 
-        manager.storage.delete('desktop:boot:storageProof');
+        omega.storage.delete('desktop:boot:storageProof');
       },
     },
   ],

package/dist/test/suites/boot/theme.test.js

@@ -16,39 +16,39 @@ module.exports = defineCases({
   tests: [
     {
       description: 'page boots with data-bs-theme equal to the resolved appearance',
-      inspect: async ({ manager, expect }) => {
+      inspect: async ({ omega, expect }) => {
         const { BrowserWindow } = require('electron');
 
-        expect(manager.theme._initialized).toBe(true);
-        expect(['light', 'dark'].includes(manager.theme.resolved())).toBe(true);
+        expect(omega.theme._initialized).toBe(true);
+        expect(['light', 'dark'].includes(omega.theme.resolved())).toBe(true);
 
         // Wait for the fixture's main window + view, then for the applier to land
         // (it applies at DOMContentLoaded).
         let attr = null;
         for (let i = 0; i < 50; i++) {
-          const win = manager.windows.get('main') || BrowserWindow.getAllWindows()[0];
+          const win = omega.windows.get('main') || BrowserWindow.getAllWindows()[0];
           if (win && !win.isDestroyed() && win.webContents.getURL().includes('/views/main/')) {
             attr = await win.webContents.executeJavaScript('document.documentElement.getAttribute("data-bs-theme")').catch(() => null);
-            if (attr === manager.theme.resolved()) break;
+            if (attr === omega.theme.resolved()) break;
           }
           await new Promise((resolve) => setTimeout(resolve, 100));
         }
 
-        expect(attr).toBe(manager.theme.resolved());
+        expect(attr).toBe(omega.theme.resolved());
       },
     },
 
     {
       description: 'main-side theme.set() updates the live page attribute (no reload)',
-      inspect: async ({ manager, expect }) => {
+      inspect: async ({ omega, expect }) => {
         const { BrowserWindow } = require('electron');
-        const win = manager.windows.get('main') || BrowserWindow.getAllWindows()[0];
+        const win = omega.windows.get('main') || BrowserWindow.getAllWindows()[0];
         expect(Boolean(win && !win.isDestroyed())).toBe(true);
 
-        const original = manager.theme.get();
-        const target = manager.theme.resolved() === 'dark' ? 'light' : 'dark';
+        const original = omega.theme.get();
+        const target = omega.theme.resolved() === 'dark' ? 'light' : 'dark';
 
-        manager.theme.set(target);
+        omega.theme.set(target);
 
         let attr = null;
         for (let i = 0; i < 50; i++) {
@@ -58,8 +58,8 @@ module.exports = defineCases({
         }
 
         // Restore before asserting so a failure can't strand the flipped state.
-        manager.theme.set(original);
-        manager.storage.delete('theme.appearance');
+        omega.theme.set(original);
+        omega.storage.delete('theme.appearance');
 
         expect(attr).toBe(target);
       },

package/dist/test/suites/build/audit.test.js

@@ -12,7 +12,7 @@ const defineCases = require('../../../vendor/devkit/test/define-cases.js');
 const auditPath = path.join(__dirname, '..', '..', '..', 'gulp', 'tasks', 'audit.js');
 
 function freshAudit() {
-  // Clear require cache so each test gets a clean module (it instantiates Manager at require time).
+  // Clear require cache so each test gets a clean module (it loads the build module at require time).
   delete require.cache[require.resolve(auditPath)];
   return require(auditPath);
 }
@@ -103,18 +103,31 @@ module.exports = defineCases({
       },
     },
     {
-      // #911: the task took only `errors` off validateConfig, so a consumer
-      // read `audit ok (0 warnings)` while the validator's list named real
-      // findings (a key the schema does not declare, which is what a typo
-      // looks like). The report is both lists now.
-      name: 'prints the validator\'s warnings and counts them (#911)',
+      // The schema is strict: a key nothing declares is what a typo (or a
+      // legacy shape) looks like, and it fails the build naming the fix.
+      name: 'an undeclared key fails the audit, naming omega migrate',
       run: async (ctx) => {
         const tmp = stageConsumer({ brand: { id: 'testapp', name: 'TestApp' } }, { notAKey: true });
+        try {
+          const err = await runAudit(tmp);
+          ctx.expect(err).toBeDefined();
+          ctx.expect(err.message).toMatch(/config\.notAKey is not a key the schema declares/);
+          ctx.expect(err.message).toMatch(/npx omega migrate/);
+        } finally {
+          fs.rmSync(tmp, { recursive: true, force: true });
+        }
+      },
+    },
+    {
+      // The resolved config carries the company the loader fills and the
+      // environment the build attaches: neither is the brand's key.
+      name: 'a clean config passes with the loader-filled and build-attached keys on it',
+      run: async (ctx) => {
+        const tmp = stageConsumer({ brand: { id: 'testapp', name: 'TestApp' } }, { electronBuilder: { mac: { hardenedRuntime: true } } });
         try {
           const { err, output } = await runAuditCapturing(tmp);
           ctx.expect(err).toBeNull();
-          ctx.expect(output).toMatch(/notAKey/);
-          ctx.expect(output).toMatch(/audit ok \(1 warning\)/);
+          ctx.expect(output).toMatch(/audit ok \(0 warnings\)/);
         } finally {
           fs.rmSync(tmp, { recursive: true, force: true });
         }

package/dist/test/suites/build/auth-persistence-resolve.test.js

@@ -3,7 +3,7 @@
 //
 // The managers are plain objects and `available()` is stubbed, so the production
 // default is provable with no Electron and, above all, with no call into this box's
-// OS keychain. The real-manager half lives in the main suite, which now runs under
+// OS keychain. The real-instance half lives in the main suite, which now runs under
 // the forced test-mode strategy itself.
 
 const path = require('path');
@@ -41,7 +41,7 @@ module.exports = defineCases({
   description: 'auth-persistence resolve(): the production default, and the test-mode override',
   tests: [
     {
-      name: 'a production manager with no config still picks safeStorage; an unknown name warns to null',
+      name: 'a production omega instance with no config still picks safeStorage; an unknown name warns to null',
       run: async (ctx) => {
         const vault = stubSafeStorage();
         const lines = [];
@@ -63,7 +63,7 @@ module.exports = defineCases({
       },
     },
     {
-      name: 'a testing manager gets none before any config read, and the vault is never asked',
+      name: 'a testing omega instance gets none before any config read, and the vault is never asked',
       run: async (ctx) => {
         const vault = stubSafeStorage();
         const lines = [];
@@ -97,13 +97,13 @@ module.exports = defineCases({
           // explicit one alone ([#925](https://github.com/Omega-JS-Stack/omega/issues/925)),
           // and so the real isTesting() answers the lane, not the bake.
           process.env[ENVIRONMENT_VAR] = 'testing';
-          const manager = {
+          const omega = {
             config:    { environment: 'production', omega: { authPersistence: 'safeStorage' } },
             isTesting,
           };
-          ctx.expect(manager.isTesting()).toBe(true);
+          ctx.expect(omega.isTesting()).toBe(true);
 
-          const active = await capture(lines, () => authPersistence.resolve(manager));
+          const active = await capture(lines, () => authPersistence.resolve(omega));
           ctx.expect(active).toBeNull();
           ctx.expect(vault.calls.available).toBe(0);
           ctx.expect(lines.join('\n')).toMatch(/auth persistence: none \(test mode\)/);

package/dist/test/suites/build/boot-fixture.test.js

@@ -15,9 +15,9 @@
 
 const path = require('path');
 
-const Manager = require('../../../build.js');
+const build = require('../../../build.js');
 
-const package = Manager.getPackage('main');
+const package = build.getPackage('main');
 const fixture = require(path.join(__dirname, '..', '..', 'fixtures', 'consumer-app', 'package.json'));
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
 

package/dist/test/suites/build/boot-runner-timeout.test.js

@@ -15,6 +15,7 @@ const jetpack = require('fs-jetpack');
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
 
 const { runBootChild } = require(path.join(__dirname, '..', '..', 'runners', 'boot.js'));
+const { TEST_EVENT_PREFIX } = require(path.join(__dirname, '..', '..', '..', 'utils', 'test-events.js'));
 
 // A project root the runner reads its report clue from. `logLine` null writes no
 // logs/ at all, the boot that died before the logger ever opened a file.
@@ -152,11 +153,11 @@ module.exports = defineCases({
             killGraceMs:   20,
           });
 
-          child.stdout.emit('data', `__EM_TEST__${JSON.stringify({ event: 'result', name: 'the app boots', passed: true, duration: 12 })}\n`);
+          child.stdout.emit('data', `${TEST_EVENT_PREFIX}${JSON.stringify({ event: 'result', name: 'the app boots', passed: true, duration: 12 })}\n`);
           await sleep(150);
-          child.stdout.emit('data', `__EM_TEST__${JSON.stringify({ event: 'result', name: 'a slow suite finishes', passed: true, duration: 12 })}\n`);
+          child.stdout.emit('data', `${TEST_EVENT_PREFIX}${JSON.stringify({ event: 'result', name: 'a slow suite finishes', passed: true, duration: 12 })}\n`);
           await sleep(150);
-          child.stdout.emit('data', `__EM_TEST__${JSON.stringify({ event: 'result', name: 'and another', passed: true, duration: 12 })}\n`);
+          child.stdout.emit('data', `${TEST_EVENT_PREFIX}${JSON.stringify({ event: 'result', name: 'and another', passed: true, duration: 12 })}\n`);
           await sleep(150);
           child.emit('exit', 0);
 
@@ -196,7 +197,7 @@ module.exports = defineCases({
             killGraceMs:   20,
           });
 
-          child.stdout.emit('data', `__EM_TEST__${JSON.stringify({ event: 'result', name: 'a late line', passed: true, duration: 12 })}\n`);
+          child.stdout.emit('data', `${TEST_EVENT_PREFIX}${JSON.stringify({ event: 'result', name: 'a late line', passed: true, duration: 12 })}\n`);
           child.emit('exit', 0);
           await sleep(40);
 
@@ -231,7 +232,7 @@ module.exports = defineCases({
             killGraceMs:   20,
           });
 
-          child.stdout.emit('data', `__EM_TEST__${JSON.stringify({ event: 'result', name: 'the app boots', passed: true, duration: 12 })}\n`);
+          child.stdout.emit('data', `${TEST_EVENT_PREFIX}${JSON.stringify({ event: 'result', name: 'the app boots', passed: true, duration: 12 })}\n`);
           child.emit('exit', 0);
 
           const settled = await pending;

package/dist/test/suites/build/brand-scss.test.js

@@ -29,7 +29,7 @@ function stageConsumer(color) {
 
 /**
  * Run the sass task with the fixture as the project root. Both the task and the
- * build Manager resolve that root at REQUIRE time, so each run gets a fresh
+ * build module resolve that root at REQUIRE time, so each run gets a fresh
  * copy of both.
  */
 function runSassIn(dir) {

package/dist/test/suites/build/build-json-bake.test.js

@@ -133,7 +133,7 @@ module.exports = defineCases({
           ctx.expect(blob.license.status).toBe('licensed');
           ctx.expect(typeof blob.builtAt).toBe('string');
           // The mode is the same THREE keys everywhere (#894): desktop's own
-          // `server` verdict stays inside the Manager.
+          // `server` verdict stays inside the build module.
           ctx.expect(Object.keys(blob.mode).sort()).toEqual(['build', 'environment', 'publish']);
           ctx.expect(blob.mode.environment).toBe('production');
           ctx.expect(blob.mode.build).toBe(true);

package/dist/test/suites/build/build-workflow-jobs.test.js

@@ -122,8 +122,8 @@ module.exports = defineCases({
         ctx.expect(decode.run).toContain('if [ -n "${{ secrets.CSC_LINK }}" ]; then');
         ctx.expect(decode.run).toContain('if [ -n "${{ secrets.APPLE_API_KEY }}" ]; then');
         // The standalone verb is gone (#891): the deploy precheck pushes them.
-        ctx.expect(decode.run).toContain('No CSC_LINK secret: run omega deploy from targets/desktop');
-        ctx.expect(decode.run).toContain('No APPLE_API_KEY secret: run omega deploy from targets/desktop');
+        ctx.expect(decode.run).toContain('No CSC_LINK secret: run omega deploy at the brand root');
+        ctx.expect(decode.run).toContain('No APPLE_API_KEY secret: run omega deploy at the brand root');
         ctx.expect(decode.run).not.toContain('push-secrets');
         ctx.expect(decode.run.match(/exit 1/g).length).toBe(2);
         ctx.expect(decode.run).not.toContain('this build will not be signed');

package/dist/test/suites/build/cli.test.js

@@ -3,9 +3,9 @@
 const path = require('path');
 const fs = require('fs');
 
-const Manager = require('../../../build.js');
+const build = require('../../../build.js');
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
-const root = Manager.getRootPath('main');
+const root = build.getRootPath('main');
 
 module.exports = defineCases({
   type: 'group',
@@ -145,6 +145,34 @@ module.exports = defineCases({
         }
       },
     },
+    {
+      name: 'update: --dry-run reaches devkit runUpdate as dryRun, and a bare run installs',
+      run: async (ctx) => {
+        const devkitUpdate = require('../../../vendor/devkit/update.js');
+        const { BOOLEAN_FLAGS } = require(path.join(root, 'dist', 'cli-run.js'));
+        const { parseArgv } = require('../../../vendor/devkit/argv.js');
+        const commandFile = path.join(root, 'dist', 'commands', 'update.js');
+
+        // The command destructures runUpdate at load, so the stub lands before a fresh require
+        async function run(args) {
+          const original = devkitUpdate.runUpdate;
+          const seen = [];
+          devkitUpdate.runUpdate = async (options) => { seen.push(options); };
+          delete require.cache[commandFile];
+          try {
+            await require(commandFile)(parseArgv(args, { booleans: BOOLEAN_FLAGS }));
+          } finally {
+            devkitUpdate.runUpdate = original;
+            delete require.cache[commandFile];
+          }
+          ctx.expect(seen.length).toBe(1);
+          return seen[0];
+        }
+
+        ctx.expect((await run(['update', '--dry-run'])).dryRun).toBe(true);
+        ctx.expect(Boolean((await run(['update'])).dryRun)).toBe(false);
+      },
+    },
     {
       name: 'mirrored aliases: -t routes to test, -d routes to deploy (wave-6 D6)',
       run: (ctx) => {

package/dist/test/suites/build/config-schema.test.js

@@ -10,9 +10,9 @@ const fs = require('fs');
 const JSON5 = require('json5');
 const { loadConfig } = require('../../../vendor/config/index.js');
 
-const Manager = require('../../../build.js');
+const build = require('../../../build.js');
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
-const root = Manager.getRootPath('main');
+const root = build.getRootPath('main');
 const defaultsDir = path.join(root, 'dist', 'defaults');
 const defaultConfigPath = path.join(defaultsDir, 'config', 'omega.json5');
 
@@ -76,7 +76,7 @@ module.exports = defineCases({
       name: 'resolved: has app block (appId + productName may be null — derived from brand)',
       run: (ctx) => {
         // appId and productName are derived from brand.id / brand.name at config-load
-        // time (Manager.getConfig). The raw scaffold leaves them null on purpose so the
+        // time (build.getConfig). The raw scaffold leaves them null on purpose so the
         // user only sets brand.{id,name} once. The `app` block itself must exist for
         // copyright + any future explicit overrides.
         ctx.expect(ctx.state.cfg.app).toBeTruthy();
@@ -96,7 +96,7 @@ module.exports = defineCases({
       run: (ctx) => {
         // Tray, menu, and context-menu use fixed conventional paths
         // (src/integrations/{tray,menu,context-menu}/index.js). Disabling is a runtime
-        // call (manager.tray.disable() etc.), not a config flag. Config carries no entry
+        // call (omega.tray.disable() etc.), not a config flag. Config carries no entry
         // for these in v1 — guard against re-introducing one accidentally.
         ctx.expect(ctx.state.cfg.tray).toBeUndefined();
         ctx.expect(ctx.state.cfg.menu).toBeUndefined();
@@ -125,7 +125,7 @@ module.exports = defineCases({
       name: 'has NO deepLinks config block (scheme = brand.id, routes are runtime)',
       run: (ctx) => {
         // deep-link scheme is auto-derived from brand.id; routes register at runtime via
-        // manager.deepLink.on(). Guard against re-introducing a config block.
+        // omega.deepLink.on(). Guard against re-introducing a config block.
         ctx.expect(ctx.state.cfg.deepLinks).toBeUndefined();
       },
     },

package/dist/test/suites/build/defaults-em-dash.test.js

@@ -0,0 +1,22 @@
+// Every defaults file is copied into a consumer's repo, whose own guard may
+// refuse an em dash (U+2014) at commit time. So no defaults file carries one.
+
+const path = require('path');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+const { dashedFiles } = require('../../../vendor/devkit/test/dashed-files.js');
+
+const DEFAULTS = path.join(__dirname, '..', '..', '..', 'defaults');
+
+module.exports = defineCases({
+  type: 'group',
+  layer: 'build',
+  description: 'defaults tree carries no em dash',
+  tests: [
+    {
+      name: 'no defaults file carries an em dash',
+      run: (ctx) => {
+        ctx.expect(dashedFiles(DEFAULTS)).toEqual([]);
+      },
+    },
+  ],
+});

package/dist/test/suites/build/defaults-scaffold.test.js

@@ -9,11 +9,11 @@ const fs = require('fs');
 const os = require('os');
 const jetpack = require('fs-jetpack');
 
-const Manager = require('../../../build.js');
+const build = require('../../../build.js');
 const { renderSecretsBlock } = require('../../../vendor/config/env-delivery.js');
 const { copyDefaults } = require('../../../commands/lib/ensure-target.js');
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
-const package = Manager.getPackage('main');
+const package = build.getPackage('main');
 
 const DEFAULT_MARKER = '# ========== Default Values ==========';
 const CUSTOM_MARKER = '# ========== Custom Values ==========';
@@ -34,10 +34,11 @@ module.exports = defineCases({
         // .env and every verb delivers them.
         ctx.expect(jetpack.exists(path.join(tmp, '.env'))).toBe(false);
         ctx.expect(jetpack.exists(path.join(tmp, '.gitignore'))).toBeTruthy();
-        // The agent-docs chain (#63): AGENTS.md carries the content, CLAUDE.md is
-        // the one-line `@AGENTS.md` pointer.
-        ctx.expect(jetpack.read(path.join(tmp, 'AGENTS.md'))).toContain('node_modules/@omega.js/AGENTS.md');
-        ctx.expect(jetpack.read(path.join(tmp, 'CLAUDE.md')).trim()).toBe('@AGENTS.md');
+        // A standalone project root gets the same AGENTS.md a brand root does:
+        // the manager import under Default, its notes under Custom. Claude Code reads
+        // AGENTS.md natively, so no CLAUDE.md scaffolds beside it.
+        ctx.expect(jetpack.read(path.join(tmp, 'AGENTS.md'))).toBe('<!-- ========== Default Values ========== -->\n@node_modules/@omega.js/manager/AGENTS.md\n\n<!-- ========== Custom Values ========== -->\n');
+        ctx.expect(jetpack.exists(path.join(tmp, 'CLAUDE.md'))).toBe(false);
         ctx.expect(jetpack.exists(path.join(tmp, '_mas'))).toBe(false);
         // `_`-prefixed FILENAMES are not archives — test/_init.js ships.
         ctx.expect(jetpack.exists(path.join(tmp, 'test', '_init.js'))).toBeTruthy();
@@ -213,6 +214,20 @@ module.exports = defineCases({
         ctx.expect(jetpack.exists(path.join(targetDir, 'config', 'omega.json5'))).toBe(false);
       },
     },
+    {
+      name: 'an old-template AGENTS.md converges, keeping the consumer notes under the Custom marker',
+      run: async (ctx) => {
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'desktop-defaults-'));
+        jetpack.write(path.join(tmp, 'AGENTS.md'),
+          `${DEFAULT_MARKER}\n# OMEGA Desktop consumer project\nframework guidance\n\n${CUSTOM_MARKER}\n\n## Project-specific notes\n\nAdd anything specific to THIS project here. Edits below this line are preserved across framework re-syncs.\n\nOur deploy needs the VPN up.\n`);
+        const warnings = [];
+        const applied = await copyDefaults(tmp, { log: () => {}, warn: (m) => warnings.push(m), error: () => {} });
+
+        ctx.expect(jetpack.read(path.join(tmp, 'AGENTS.md'))).toBe('<!-- ========== Default Values ========== -->\n@node_modules/@omega.js/manager/AGENTS.md\n\n<!-- ========== Custom Values ========== -->\nOur deploy needs the VPN up.\n');
+        ctx.expect(applied.merged.includes('AGENTS.md')).toBe(true);
+        ctx.expect(warnings.some((m) => m.includes('Converged AGENTS.md'))).toBe(true);
+      },
+    },
     {
       name: 'brand target scaffolds NO per-target docs (brand doc unification: the brand root is the doc home)',
       run: async (ctx) => {
@@ -240,7 +255,6 @@ module.exports = defineCases({
         // Standalone scaffold first (no brand config yet) — per-target docs land.
         await copyDefaults(targetDir);
         ctx.expect(jetpack.exists(path.join(targetDir, 'AGENTS.md'))).toBeTruthy();
-        ctx.expect(jetpack.exists(path.join(targetDir, 'CLAUDE.md'))).toBeTruthy();
 
         // Wrap it in a brand monorepo: the next setup sweeps the untouched docs.
         jetpack.write(path.join(tmp, 'brand', 'config', 'omega.json5'), "{ brand: { id: 'acme', name: 'Acme' } }\n");