@omega.js/desktop 0.51.0 → 0.53.0

package/dist/test/suites/main/remote-scripts.test.js

@@ -8,117 +8,117 @@ module.exports = defineCases({
   layer: 'main',
   description: 'remote-scripts (main)',
   cleanup: (ctx) => {
-    ctx.manager.remoteScripts.shutdown();
-    ctx.manager.storage.set('remoteScripts.lastRun', null);
-    ctx.manager.remoteScripts.initialize(ctx.manager);
+    ctx.omega.remoteScripts.shutdown();
+    ctx.omega.storage.set('remoteScripts.lastRun', null);
+    ctx.omega.remoteScripts.initialize(ctx.omega);
   },
   tests: [
     // ─── Boot wiring ────────────────────────────────────────────────────────
     {
-      name: 'remoteScripts module wired on manager + initialized during boot',
+      name: 'remoteScripts module wired on omega + initialized during boot',
       run: (ctx) => {
-        ctx.expect(ctx.manager.remoteScripts).toBeDefined();
-        ctx.expect(ctx.manager.remoteScripts._initialized).toBe(true);
+        ctx.expect(ctx.omega.remoteScripts).toBeDefined();
+        ctx.expect(ctx.omega.remoteScripts._initialized).toBe(true);
       },
     },
     {
       name: 'off by default: no config.remoteScripts → lane disabled (no URL, no interval)',
       run: (ctx) => {
-        ctx.manager.remoteScripts.shutdown();
-        const orig = ctx.manager.config.remoteScripts;
-        delete ctx.manager.config.remoteScripts;
+        ctx.omega.remoteScripts.shutdown();
+        const orig = ctx.omega.config.remoteScripts;
+        delete ctx.omega.config.remoteScripts;
         try {
-          ctx.manager.remoteScripts.initialize(ctx.manager);
-          ctx.expect(ctx.manager.remoteScripts._enabled).toBe(false);
-          ctx.expect(ctx.manager.remoteScripts._url).toBe(null);
-          ctx.expect(ctx.manager.remoteScripts._intervalId).toBe(null);
+          ctx.omega.remoteScripts.initialize(ctx.omega);
+          ctx.expect(ctx.omega.remoteScripts._enabled).toBe(false);
+          ctx.expect(ctx.omega.remoteScripts._url).toBe(null);
+          ctx.expect(ctx.omega.remoteScripts._intervalId).toBe(null);
         } finally {
-          ctx.manager.remoteScripts.shutdown();
-          ctx.manager.config.remoteScripts = orig;
-          ctx.manager.remoteScripts.initialize(ctx.manager);
+          ctx.omega.remoteScripts.shutdown();
+          ctx.omega.config.remoteScripts = orig;
+          ctx.omega.remoteScripts.initialize(ctx.omega);
         }
       },
     },
     {
       name: 'opted in without explicit url: URL derived from brand.url + /data/scripts/main.js',
       run: (ctx) => {
-        ctx.manager.remoteScripts.shutdown();
-        const orig = ctx.manager.config.remoteScripts;
-        const origBrandUrl = ctx.manager.config.brand.url;
+        ctx.omega.remoteScripts.shutdown();
+        const orig = ctx.omega.config.remoteScripts;
+        const origBrandUrl = ctx.omega.config.brand.url;
         // Synthetic loopback brand.url: initialize() fires a real refreshNow(),
         // and in a CONSUMER test run the real brand.url could serve a script
         // this lane would EXECUTE. Port 59987 is deliberately unlikely to listen.
-        ctx.manager.config.brand.url = 'http://localhost:59987';
-        ctx.manager.config.remoteScripts = { enabled: true };
+        ctx.omega.config.brand.url = 'http://localhost:59987';
+        ctx.omega.config.remoteScripts = { enabled: true };
         try {
-          ctx.manager.remoteScripts.initialize(ctx.manager);
+          ctx.omega.remoteScripts.initialize(ctx.omega);
           // brand.url is set, so the URL must actually derive — a null here
           // would let the assertion pass vacuously.
-          ctx.expect(ctx.manager.remoteScripts._url).toBe('http://localhost:59987/data/scripts/main.js');
+          ctx.expect(ctx.omega.remoteScripts._url).toBe('http://localhost:59987/data/scripts/main.js');
         } finally {
-          ctx.manager.remoteScripts.shutdown();
-          ctx.manager.config.remoteScripts = orig;
-          ctx.manager.config.brand.url = origBrandUrl;
-          ctx.manager.remoteScripts.initialize(ctx.manager);
+          ctx.omega.remoteScripts.shutdown();
+          ctx.omega.config.remoteScripts = orig;
+          ctx.omega.config.brand.url = origBrandUrl;
+          ctx.omega.remoteScripts.initialize(ctx.omega);
         }
       },
     },
     {
       name: 'URL override: config.remoteScripts.url wins over brand.url',
       run: (ctx) => {
-        ctx.manager.remoteScripts.shutdown();
-        const orig = ctx.manager.config.remoteScripts;
-        ctx.manager.config.remoteScripts = { enabled: true, url: 'https://override.example/patch.js' };
+        ctx.omega.remoteScripts.shutdown();
+        const orig = ctx.omega.config.remoteScripts;
+        ctx.omega.config.remoteScripts = { enabled: true, url: 'https://override.example/patch.js' };
         try {
-          ctx.manager.remoteScripts.initialize(ctx.manager);
-          ctx.expect(ctx.manager.remoteScripts._url).toBe('https://override.example/patch.js');
+          ctx.omega.remoteScripts.initialize(ctx.omega);
+          ctx.expect(ctx.omega.remoteScripts._url).toBe('https://override.example/patch.js');
         } finally {
-          ctx.manager.remoteScripts.shutdown();
-          ctx.manager.config.remoteScripts = orig;
-          ctx.manager.remoteScripts.initialize(ctx.manager);
+          ctx.omega.remoteScripts.shutdown();
+          ctx.omega.config.remoteScripts = orig;
+          ctx.omega.remoteScripts.initialize(ctx.omega);
         }
       },
     },
     {
       name: 'transport gate: non-https URL refused (lane disabled), loopback http allowed',
       run: (ctx) => {
-        const orig = ctx.manager.config.remoteScripts;
+        const orig = ctx.omega.config.remoteScripts;
         try {
-          ctx.manager.remoteScripts.shutdown();
-          ctx.manager.config.remoteScripts = { enabled: true, url: 'http://insecure.example/patch.js' };
-          ctx.manager.remoteScripts.initialize(ctx.manager);
-          ctx.expect(ctx.manager.remoteScripts._url).toBe(null);
-          ctx.expect(ctx.manager.remoteScripts._intervalId).toBe(null);
+          ctx.omega.remoteScripts.shutdown();
+          ctx.omega.config.remoteScripts = { enabled: true, url: 'http://insecure.example/patch.js' };
+          ctx.omega.remoteScripts.initialize(ctx.omega);
+          ctx.expect(ctx.omega.remoteScripts._url).toBe(null);
+          ctx.expect(ctx.omega.remoteScripts._intervalId).toBe(null);
 
           // Port 59987 is deliberately unlikely to be listening — initialize()
           // fires a real refreshNow(), and a live port (4000 = the web dev
           // server) would have its response body EXECUTED by this lane.
-          ctx.manager.remoteScripts.shutdown();
-          ctx.manager.config.remoteScripts = { enabled: true, url: 'http://localhost:59987/patch.js' };
-          ctx.manager.remoteScripts.initialize(ctx.manager);
-          ctx.expect(ctx.manager.remoteScripts._url).toBe('http://localhost:59987/patch.js');
+          ctx.omega.remoteScripts.shutdown();
+          ctx.omega.config.remoteScripts = { enabled: true, url: 'http://localhost:59987/patch.js' };
+          ctx.omega.remoteScripts.initialize(ctx.omega);
+          ctx.expect(ctx.omega.remoteScripts._url).toBe('http://localhost:59987/patch.js');
         } finally {
-          ctx.manager.remoteScripts.shutdown();
-          ctx.manager.config.remoteScripts = orig;
-          ctx.manager.remoteScripts.initialize(ctx.manager);
+          ctx.omega.remoteScripts.shutdown();
+          ctx.omega.config.remoteScripts = orig;
+          ctx.omega.remoteScripts.initialize(ctx.omega);
         }
       },
     },
     {
       name: 'enabled=false: skip everything',
       run: (ctx) => {
-        ctx.manager.remoteScripts.shutdown();
-        const orig = ctx.manager.config.remoteScripts;
-        ctx.manager.config.remoteScripts = { enabled: false };
+        ctx.omega.remoteScripts.shutdown();
+        const orig = ctx.omega.config.remoteScripts;
+        ctx.omega.config.remoteScripts = { enabled: false };
         try {
-          ctx.manager.remoteScripts.initialize(ctx.manager);
-          ctx.expect(ctx.manager.remoteScripts._enabled).toBe(false);
-          ctx.expect(ctx.manager.remoteScripts._url).toBe(null);
-          ctx.expect(ctx.manager.remoteScripts._intervalId).toBe(null);
+          ctx.omega.remoteScripts.initialize(ctx.omega);
+          ctx.expect(ctx.omega.remoteScripts._enabled).toBe(false);
+          ctx.expect(ctx.omega.remoteScripts._url).toBe(null);
+          ctx.expect(ctx.omega.remoteScripts._intervalId).toBe(null);
         } finally {
-          ctx.manager.remoteScripts.shutdown();
-          ctx.manager.config.remoteScripts = orig;
-          ctx.manager.remoteScripts.initialize(ctx.manager);
+          ctx.omega.remoteScripts.shutdown();
+          ctx.omega.config.remoteScripts = orig;
+          ctx.omega.remoteScripts.initialize(ctx.omega);
         }
       },
     },
@@ -127,9 +127,9 @@ module.exports = defineCases({
     {
       name: '_hash: stable — same input produces same 16-char hex',
       run: (ctx) => {
-        const rs = ctx.manager.remoteScripts;
-        const h1 = rs._hash('manager.storage.delete("x");');
-        const h2 = rs._hash('manager.storage.delete("x");');
+        const rs = ctx.omega.remoteScripts;
+        const h1 = rs._hash('omega.storage.delete("x");');
+        const h2 = rs._hash('omega.storage.delete("x");');
         ctx.expect(h1).toBe(h2);
         ctx.expect(typeof h1).toBe('string');
         ctx.expect(h1.length).toBe(16);
@@ -138,41 +138,41 @@ module.exports = defineCases({
     {
       name: '_hash: different input produces different hash',
       run: (ctx) => {
-        const rs = ctx.manager.remoteScripts;
+        const rs = ctx.omega.remoteScripts;
         ctx.expect(rs._hash('script v1')).not.toBe(rs._hash('script v2'));
       },
     },
 
     // ─── Execution ──────────────────────────────────────────────────────────
     {
-      name: '_execute: runs code with manager in scope',
+      name: '_execute: runs code with omega in scope',
       run: async (ctx) => {
-        ctx.manager._remoteScriptTestResult = null;
-        await ctx.manager.remoteScripts._execute('manager._remoteScriptTestResult = 42;');
-        ctx.expect(ctx.manager._remoteScriptTestResult).toBe(42);
-        delete ctx.manager._remoteScriptTestResult;
+        ctx.omega._remoteScriptTestResult = null;
+        await ctx.omega.remoteScripts._execute('omega._remoteScriptTestResult = 42;');
+        ctx.expect(ctx.omega._remoteScriptTestResult).toBe(42);
+        delete ctx.omega._remoteScriptTestResult;
       },
     },
     {
       name: '_execute: supports async code (await)',
       run: async (ctx) => {
-        ctx.manager._remoteScriptTestResult = null;
-        await ctx.manager.remoteScripts._execute(
-          'const v = await Promise.resolve(99); manager._remoteScriptTestResult = v;',
+        ctx.omega._remoteScriptTestResult = null;
+        await ctx.omega.remoteScripts._execute(
+          'const v = await Promise.resolve(99); omega._remoteScriptTestResult = v;',
         );
-        ctx.expect(ctx.manager._remoteScriptTestResult).toBe(99);
-        delete ctx.manager._remoteScriptTestResult;
+        ctx.expect(ctx.omega._remoteScriptTestResult).toBe(99);
+        delete ctx.omega._remoteScriptTestResult;
       },
     },
     {
       name: '_execute: require is available (e.g. require("path"))',
       run: async (ctx) => {
-        ctx.manager._remoteScriptTestResult = null;
-        await ctx.manager.remoteScripts._execute(
-          'const path = require("path"); manager._remoteScriptTestResult = typeof path.join;',
+        ctx.omega._remoteScriptTestResult = null;
+        await ctx.omega.remoteScripts._execute(
+          'const path = require("path"); omega._remoteScriptTestResult = typeof path.join;',
         );
-        ctx.expect(ctx.manager._remoteScriptTestResult).toBe('function');
-        delete ctx.manager._remoteScriptTestResult;
+        ctx.expect(ctx.omega._remoteScriptTestResult).toBe('function');
+        delete ctx.omega._remoteScriptTestResult;
       },
     },
     {
@@ -180,7 +180,7 @@ module.exports = defineCases({
       run: async (ctx) => {
         let threw = false;
         try {
-          await ctx.manager.remoteScripts._execute('throw new Error("boom");');
+          await ctx.omega.remoteScripts._execute('throw new Error("boom");');
         } catch (e) {
           threw = true;
           ctx.expect(e.message).toBe('boom');
@@ -193,33 +193,33 @@ module.exports = defineCases({
     {
       name: 'getLastRun returns null when no script has run',
       run: (ctx) => {
-        ctx.manager.storage.set('remoteScripts.lastRun', null);
-        ctx.expect(ctx.manager.remoteScripts.getLastRun()).toBe(null);
+        ctx.omega.storage.set('remoteScripts.lastRun', null);
+        ctx.expect(ctx.omega.remoteScripts.getLastRun()).toBe(null);
       },
     },
     {
       name: 'clearExecuted wipes stored hash',
       run: (ctx) => {
-        ctx.manager.storage.set('remoteScripts.lastRun', { hash: 'abc', timestamp: 1 });
-        ctx.expect(ctx.manager.remoteScripts.getLastRun()).toEqual({ hash: 'abc', timestamp: 1 });
-        ctx.manager.remoteScripts.clearExecuted();
-        ctx.expect(ctx.manager.remoteScripts.getLastRun()).toBe(null);
+        ctx.omega.storage.set('remoteScripts.lastRun', { hash: 'abc', timestamp: 1 });
+        ctx.expect(ctx.omega.remoteScripts.getLastRun()).toEqual({ hash: 'abc', timestamp: 1 });
+        ctx.omega.remoteScripts.clearExecuted();
+        ctx.expect(ctx.omega.remoteScripts.getLastRun()).toBe(null);
       },
     },
     {
       name: 'refreshNow returns null when disabled',
       run: async (ctx) => {
-        ctx.manager.remoteScripts.shutdown();
-        const orig = ctx.manager.config.remoteScripts;
-        ctx.manager.config.remoteScripts = { enabled: false };
+        ctx.omega.remoteScripts.shutdown();
+        const orig = ctx.omega.config.remoteScripts;
+        ctx.omega.config.remoteScripts = { enabled: false };
         try {
-          ctx.manager.remoteScripts.initialize(ctx.manager);
-          const result = await ctx.manager.remoteScripts.refreshNow();
+          ctx.omega.remoteScripts.initialize(ctx.omega);
+          const result = await ctx.omega.remoteScripts.refreshNow();
           ctx.expect(result).toBe(null);
         } finally {
-          ctx.manager.remoteScripts.shutdown();
-          ctx.manager.config.remoteScripts = orig;
-          ctx.manager.remoteScripts.initialize(ctx.manager);
+          ctx.omega.remoteScripts.shutdown();
+          ctx.omega.config.remoteScripts = orig;
+          ctx.omega.remoteScripts.initialize(ctx.omega);
         }
       },
     },
@@ -227,18 +227,18 @@ module.exports = defineCases({
     {
       name: 'full pipeline: execute script → storage patched → hash stored → same script skipped → changed script re-runs',
       run: async (ctx) => {
-        const rs = ctx.manager.remoteScripts;
+        const rs = ctx.omega.remoteScripts;
         rs.clearExecuted();
 
-        const scriptV1 = 'manager.storage.set("remoteScripts._test.patched", true);';
-        const scriptV2 = 'manager.storage.set("remoteScripts._test.patched", "v2");';
+        const scriptV1 = 'omega.storage.set("remoteScripts._test.patched", true);';
+        const scriptV2 = 'omega.storage.set("remoteScripts._test.patched", "v2");';
 
         // 1. Execute v1 — should patch storage
         await rs._execute(scriptV1);
         const hashV1 = rs._hash(scriptV1);
-        ctx.manager.storage.set('remoteScripts.lastRun', { hash: hashV1, timestamp: Date.now() });
+        ctx.omega.storage.set('remoteScripts.lastRun', { hash: hashV1, timestamp: Date.now() });
 
-        ctx.expect(ctx.manager.storage.get('remoteScripts._test.patched')).toBe(true);
+        ctx.expect(ctx.omega.storage.get('remoteScripts._test.patched')).toBe(true);
         ctx.expect(rs.getLastRun().hash).toBe(hashV1);
 
         // 2. Same script again — hash matches, should be skipped
@@ -251,25 +251,25 @@ module.exports = defineCases({
         ctx.expect(hashV2).not.toBe(hashV1); // proves the hash changes
 
         await rs._execute(scriptV2);
-        ctx.expect(ctx.manager.storage.get('remoteScripts._test.patched')).toBe('v2');
+        ctx.expect(ctx.omega.storage.get('remoteScripts._test.patched')).toBe('v2');
 
         // Cleanup
-        ctx.manager.storage.delete('remoteScripts._test.patched');
+        ctx.omega.storage.delete('remoteScripts._test.patched');
       },
     },
 
     {
       name: 'shutdown resets all internal state',
       run: (ctx) => {
-        ctx.manager.remoteScripts.shutdown();
-        const rs = ctx.manager.remoteScripts;
+        ctx.omega.remoteScripts.shutdown();
+        const rs = ctx.omega.remoteScripts;
         ctx.expect(rs._initialized).toBe(false);
-        ctx.expect(rs._manager).toBe(null);
+        ctx.expect(rs._omega).toBe(null);
         ctx.expect(rs._url).toBe(null);
         ctx.expect(rs._enabled).toBe(false);
         ctx.expect(rs._intervalId).toBe(null);
         // Re-init for cleanup handler
-        rs.initialize(ctx.manager);
+        rs.initialize(ctx.omega);
       },
     },
   ],

package/dist/test/suites/main/request.test.js

@@ -0,0 +1,71 @@
+// Main-process tests for `omega.request()`: the harmonized API fetch, built once
+// on the instance through @omega.js/client's createRequest, the extension
+// background's shape ([#945](https://github.com/Omega-JS-Stack/omega/issues/945)).
+//
+// The API is a real local HTTP server; the one seam is main's Firebase session
+// (`omega.auth._firebaseAuth`), because a real signed-in session needs the auth
+// emulator, which the e2e-desktop lane drives.
+
+const http = require('http');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+// A local API that records what reaches it and answers `{ ok: true }`
+async function startApi() {
+  const received = [];
+  const server = http.createServer((req, res) => {
+    let body = '';
+    req.on('data', (chunk) => { body += chunk; });
+    req.on('end', () => {
+      received.push({ method: req.method, url: req.url, authorization: req.headers.authorization, body });
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true }));
+    });
+  });
+  await new Promise((resolve) => server.listen(0, resolve));
+  return { port: server.address().port, received, close: () => new Promise((resolve) => server.close(resolve)) };
+}
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'main',
+  description: 'omega.request (main)',
+  tests: [
+    {
+      name: 'omega.request posts with the token omega.auth.getIdToken returns; signed out, getIdToken is null',
+      run: async (ctx) => {
+        const auth = ctx.omega.auth;
+        const api = await startApi();
+        const saved = {
+          firebaseAuth: auth._firebaseAuth,
+          https:        process.env.OMEGA_HTTPS_PORT,
+          hosting:      process.env.OMEGA_HOSTING_PORT,
+        };
+
+        try {
+          auth._firebaseAuth = { currentUser: { getIdToken: async () => 'token-1' } };
+          ctx.expect(await auth.getIdToken()).toBe('token-1');
+
+          // The API base is read as the call starts: the local stack, here this server
+          delete process.env.OMEGA_HTTPS_PORT;
+          process.env.OMEGA_HOSTING_PORT = String(api.port);
+          const answer = await ctx.omega.request('/notes', { method: 'POST', body: { text: 'hi' } });
+
+          ctx.expect(answer).toEqual({ ok: true });
+          ctx.expect(api.received).toEqual([{ method: 'POST', url: '/notes', authorization: 'Bearer token-1', body: '{"text":"hi"}' }]);
+
+          auth._firebaseAuth = { currentUser: null };
+          ctx.expect(await auth.getIdToken()).toBeNull();
+          auth._firebaseAuth = null;
+          ctx.expect(await auth.getIdToken()).toBeNull();
+        } finally {
+          auth._firebaseAuth = saved.firebaseAuth;
+          if (saved.https === undefined) delete process.env.OMEGA_HTTPS_PORT;
+          else process.env.OMEGA_HTTPS_PORT = saved.https;
+          if (saved.hosting === undefined) delete process.env.OMEGA_HOSTING_PORT;
+          else process.env.OMEGA_HOSTING_PORT = saved.hosting;
+          await api.close();
+        }
+      },
+    },
+  ],
+});

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

@@ -85,14 +85,14 @@ module.exports = defineCases({
   description: 'restart-manager (main)',
   cleanup: async (ctx) => {
     if (ctx.state.rm) ctx.state.rm.server.close();
-    ctx.manager.restartManager.shutdown();
-    ctx.manager.restartManager.initialize(ctx.manager);
+    ctx.omega.restartManager.shutdown();
+    ctx.omega.restartManager.initialize(ctx.omega);
   },
   tests: [
     {
-      name: 'wired on manager with the full v2 API surface',
+      name: 'wired on omega with the full v2 API surface',
       run: (ctx) => {
-        const rm = ctx.manager.restartManager;
+        const rm = ctx.omega.restartManager;
         ctx.expect(rm).toBeDefined();
         for (const fn of ['register', 'unregister', 'ensureInstalled', 'ensureRunning', 'getStatus', 'shutdown']) {
           ctx.expect(typeof rm[fn]).toBe('function');
@@ -102,7 +102,7 @@ module.exports = defineCases({
     {
       name: 'testing bail: bailed with reason, no timer, no before-quit hook',
       run: (ctx) => {
-        const rm = ctx.manager.restartManager;
+        const rm = ctx.omega.restartManager;
         const status = rm.getStatus();
         ctx.expect(status.bailed).toBe(true);
         ctx.expect(status.bailReason).toBe('testing');
@@ -114,7 +114,7 @@ module.exports = defineCases({
       name: 'testing-root isolation: _root lives under the (Testing) userData, never appData',
       run: (ctx) => {
         const { app } = require('electron');
-        const rm = ctx.manager.restartManager;
+        const rm = ctx.omega.restartManager;
         ctx.expect(rm._root.startsWith(app.getPath('userData'))).toBe(true);
         ctx.expect(rm._root).not.toBe(protocol.resolveSharedRoot(app.getPath('appData'), {}));
       },
@@ -122,38 +122,38 @@ module.exports = defineCases({
     {
       name: 'enabled=false bail (reason disabled, no timer)',
       run: (ctx) => {
-        const rm = ctx.manager.restartManager;
+        const rm = ctx.omega.restartManager;
         rm.shutdown();
-        const orig = ctx.manager.config.restartManager;
-        ctx.manager.config.restartManager = { enabled: false };
+        const orig = ctx.omega.config.restartManager;
+        ctx.omega.config.restartManager = { enabled: false };
         try {
-          rm.initialize(ctx.manager);
+          rm.initialize(ctx.omega);
           // Testing bail fires first in the harness, so force-evaluate the
           // config path: _enabled captured false proves the knob was read.
           ctx.expect(rm._enabled).toBe(false);
           ctx.expect(rm._registerTimer).toBe(null);
         } finally {
           rm.shutdown();
-          ctx.manager.config.restartManager = orig;
-          rm.initialize(ctx.manager);
+          ctx.omega.config.restartManager = orig;
+          rm.initialize(ctx.omega);
         }
       },
     },
     {
       name: 'brand.id === "restart-manager" bail (RM does not manage itself)',
       run: (ctx) => {
-        const rm = ctx.manager.restartManager;
+        const rm = ctx.omega.restartManager;
         rm.shutdown();
-        const origBrand = ctx.manager.config.brand;
-        ctx.manager.config.brand = { ...origBrand, id: 'restart-manager' };
+        const origBrand = ctx.omega.config.brand;
+        ctx.omega.config.brand = { ...origBrand, id: 'restart-manager' };
         try {
-          rm.initialize(ctx.manager);
+          rm.initialize(ctx.omega);
           ctx.expect(rm._registerTimer).toBe(null);
           ctx.expect(rm.getStatus().bailed).toBe(true);
         } finally {
           rm.shutdown();
-          ctx.manager.config.brand = origBrand;
-          rm.initialize(ctx.manager);
+          ctx.omega.config.brand = origBrand;
+          rm.initialize(ctx.omega);
         }
       },
     },
@@ -161,14 +161,14 @@ module.exports = defineCases({
       name: 'non-production without OMEGA_RESTART_MANAGER_DEV: nothing scheduled',
       run: (ctx) => {
         ctx.expect(process.env.OMEGA_RESTART_MANAGER_DEV).not.toBe('1');
-        ctx.expect(ctx.manager.isProduction()).toBe(false);
-        ctx.expect(ctx.manager.restartManager._registerTimer).toBe(null);
+        ctx.expect(ctx.omega.isProduction()).toBe(false);
+        ctx.expect(ctx.omega.restartManager._registerTimer).toBe(null);
       },
     },
     {
       name: '_readRuntime: valid file parses; wrong version / malformed / missing → null',
       run: (ctx) => {
-        const rm = ctx.manager.restartManager;
+        const rm = ctx.omega.restartManager;
         const runtimePath = protocol.getRuntimePath(rm._root);
 
         writeRuntime(rm._root, 4000);
@@ -189,7 +189,7 @@ module.exports = defineCases({
     {
       name: '_pidAlive: own pid alive, absurd pid dead',
       run: (ctx) => {
-        const rm = ctx.manager.restartManager;
+        const rm = ctx.omega.restartManager;
         ctx.expect(rm._pidAlive(process.pid)).toBe(true);
         ctx.expect(rm._pidAlive(999999)).toBe(false);
       },
@@ -197,14 +197,14 @@ module.exports = defineCases({
     {
       name: 'register round-trip: contract-valid payload lands, pid is ours, status flips',
       run: async (ctx) => {
-        const rm = ctx.manager.restartManager;
+        const rm = ctx.omega.restartManager;
         ctx.state.rm = await startContractServer();
         writeRuntime(rm._root, ctx.state.rm.port);
 
         const ok = await rm.register();
         ctx.expect(ok).toBe(true);
 
-        const appId = ctx.manager.config.brand.id;
+        const appId = ctx.omega.config.brand.id;
         const stored = ctx.state.rm.apps.get(appId);
         ctx.expect(stored).toBeDefined();
         ctx.expect(stored.pid).toBe(process.pid);
@@ -219,7 +219,7 @@ module.exports = defineCases({
     {
       name: 'heartbeat: idempotent upsert (1 app, request count climbs), timestamp advances',
       run: async (ctx) => {
-        const rm = ctx.manager.restartManager;
+        const rm = ctx.omega.restartManager;
         const before = ctx.state.rm.counts.register;
 
         await rm._heartbeatTick();
@@ -233,7 +233,7 @@ module.exports = defineCases({
     {
       name: 'quit flush: capped deregister lands under the 1s budget',
       run: async (ctx) => {
-        const rm = ctx.manager.restartManager;
+        const rm = ctx.omega.restartManager;
         const started = Date.now();
         await rm._quitFlush();
         ctx.expect(Date.now() - started).toBeLessThan(1000 + 250);
@@ -245,9 +245,9 @@ module.exports = defineCases({
       name: '_handleBeforeQuit: not-registered path returns without touching the event',
       run: (ctx) => {
         // Only the safe branch is drivable in the harness (the flush branch ends
-        // in manager.quit which would kill the test Electron). _quitFlush itself
+        // in omega.quit which would kill the test Electron). _quitFlush itself
         // is proven above.
-        const rm = ctx.manager.restartManager;
+        const rm = ctx.omega.restartManager;
         rm._registered = false;
         rm._quitFlushed = false;
         let prevented = false;
@@ -258,7 +258,7 @@ module.exports = defineCases({
     {
       name: 'deregister round-trip: fixture saw { id, pid }',
       run: async (ctx) => {
-        const rm = ctx.manager.restartManager;
+        const rm = ctx.omega.restartManager;
         await rm.register();
         ctx.expect(ctx.state.rm.apps.size).toBe(1);
 
@@ -271,7 +271,7 @@ module.exports = defineCases({
     {
       name: 'dead server: register resolves false, lastError set, no spawn in testing',
       run: async (ctx) => {
-        const rm = ctx.manager.restartManager;
+        const rm = ctx.omega.restartManager;
         // Grab a port that WAS listening and now is not.
         const throwaway = await startContractServer();
         const deadPort = throwaway.port;
@@ -286,7 +286,7 @@ module.exports = defineCases({
     {
       name: 'smart existence: installed app on disk short-circuits before any network',
       run: async (ctx) => {
-        const rm = ctx.manager.restartManager;
+        const rm = ctx.omega.restartManager;
         const appPath = protocol.getInstalledAppPath(rm._root, process.platform);
         fs.mkdirSync(appPath, { recursive: true });
         try {
@@ -301,7 +301,7 @@ module.exports = defineCases({
     {
       name: 'not installed in testing: ensureInstalled refuses network and returns false',
       run: async (ctx) => {
-        const rm = ctx.manager.restartManager;
+        const rm = ctx.omega.restartManager;
         if (process.env.TEST_EXTENDED_MODE) return ctx.skip('extended mode allows the real download');
         const ok = await rm.ensureInstalled();
         ctx.expect(ok).toBe(false);
@@ -312,7 +312,7 @@ module.exports = defineCases({
       run: async (ctx) => {
         if (!process.env.TEST_EXTENDED_MODE) return ctx.skip('requires TEST_EXTENDED_MODE (live GitHub)');
         const install = require('../../../lib/restart-manager/install.js');
-        const rm = ctx.manager.restartManager;
+        const rm = ctx.omega.restartManager;
         try {
           const feed = await install.fetchFeed(rm._feed, process.platform);
           const artifact = install.pickArtifact(feed, process.platform, process.arch);