@omega.js/desktop 0.50.0 → 0.51.0

package/dist/build.js

@@ -1,17 +1,11 @@
 // Libraries
 const path = require('path');
 const jetpack = require('fs-jetpack');
+const { setEnvironment, buildLaneEnvironment } = require('./vendor/config/environment.js');
 const fs = require('fs');
 const JSON5 = require('json5');
 const { force, execute } = require('node-powertools');
-
-// argv is parsed lazily — yargs is ESM-only and can't be `require()`'d in older Node runtimes.
-let _argv = null;
-function getArgv() {
-  if (_argv) return _argv;
-  _argv = require('yargs')(process.argv.slice(2)).parseSync();
-  return _argv;
-}
+const { parseArgv } = require('./vendor/devkit/argv.js');
 
 // Class
 function Manager() {
@@ -44,11 +38,11 @@ Manager.prototype.logger = function (name) {
   return this._logger;
 };
 
-// argv (yargs is loaded on first call so the runtime build.js doesn't pull in ESM-only deps)
+// argv: the gulp lane's own parse. It is spawned with the TASK NAME alone
+// (`npm run gulp -- build`), so `debug` is the one flag it declares.
 Manager.getArguments = function () {
-  const options = getArgv() || {};
+  const options = parseArgv(process.argv.slice(2), { booleans: ['debug'] });
 
-  options._ = options._ || [];
   options.debug = force(options.debug === undefined ? false : options.debug, 'boolean');
 
   return options;
@@ -92,12 +86,29 @@ Manager.actLikeProduction = function () {
 };
 Manager.prototype.actLikeProduction = Manager.actLikeProduction;
 
-// getEnvironment() is the SINGLE SOURCE OF TRUTH and lives in src/utils/mode-helpers.js
-// (alongside isDevelopment/isProduction/isTesting — the natural environment-helper family).
-// It's mixed into ALL FOUR @omega.js/desktop Manager entry points (main / renderer / preload / build) via
-// the mode-helpers attachTo() call at the bottom of each, so every context resolves the
-// environment identically. (@omega.js/desktop has four separate Manager constructors that share code only
-// through these mixins — unlike UJM/BXM, where one build.js Manager serves every context.)
+// The environment is the ONE module's (@omega.js/config's environment.js,
+// [#817](https://github.com/Omega-JS-Stack/omega/issues/817)), reachable from
+// all four @omega.js/desktop Manager entry points (main / renderer / preload /
+// build) through the mode-helpers attachTo() call at the bottom of each, so
+// every context resolves it identically. It reads ONE input and never guesses.
+//
+// THIS FILE IS THE NODE LANE'S ONE SETTER, and it runs at load, before any
+// gulp task, verb or getConfig() asks. Two rules, no sniffing:
+//   1. OMEGA_BUILD_MODE is the lane saying it is producing a PRODUCTION
+//      artifact (`omega build` / `package` / `publish` / `release` all set it,
+//      and so does the boot runner's staged build). It WINS over an inherited
+//      variable, so a production build spawned from a test run still bakes
+//      production.
+//   2. Otherwise a lane that already named one keeps it (the test runners spawn
+//      their children with `testing`), and a bare dev boot is `development`.
+// Before #817 a dev boot with no signal answered `production` here, so
+// `npm start` bundled itself as a production artifact, while the extension's
+// copy of the same function answered `development` from the same inputs.
+//
+// The electron app this lane spawns inherits the variable; a PACKAGED app has
+// no parent env, so main.js sets it from the baked config instead (the same
+// word, written into the artifact by the bundle task).
+setEnvironment(buildLaneEnvironment(Manager.isBuildMode()));
 
 Manager.getMode = function () {
   return {
@@ -114,28 +125,58 @@ Manager.prototype.getMode = Manager.getMode;
 // theme) at the top level, targets.desktop overlaid onto them (so app/platforms/startup/
 // releases/... land at the top level here), and in a brand monorepo the brand root's
 // config merges underneath the target's. Then @omega.js/desktop's derived defaults:
-//   app.appId       ← reverse-domain of brand.url (`https://foo.example.com` →
-//                     `com.example.foo`), else `app.${brand.id}` — the BRAND
-//                     owns the identity, never a hardcoded company (friction #18)
+//   app.appId       ← certificates.providers.apple.bundleIdPrefix + brand.id,
+//                     dashes as dots (`com.example` + `my-app` →
+//                     `com.example.my.app`), the same id the
+//                     certificates service registers (#909). No prefix
+//                     declared → reverse-domain of brand.url
+//                     (`https://foo.example.com` → `com.example.foo`), else
+//                     `app.${brand.id}`: the BRAND owns the identity, never a
+//                     hardcoded company (friction #18)
 //   app.productName ← brand.name if not set
 // These keep the consumer's config minimal: setting `brand: { id: 'foo', name: 'Foo',
 // url: 'https://foo.com' }` is enough; appId/productName flow through automatically.
 Manager.getConfig = function () {
-  const { hasOmegaConfig, loadConfig } = require('./vendor/config/index.js');
+  const { hasOmegaConfig, loadConfig, composeBundleId, deriveBundleIdPrefix } = require('./vendor/config/index.js');
+
+  // WHICH environment overlay composes
+  // ([#856](https://github.com/Omega-JS-Stack/omega/issues/856)): a build bakes
+  // a PRODUCTION artifact, so it names production rather than asking the
+  // machine, which answers `development` in a terminal. That decision is now
+  // made ONCE, at the top of this file, and lands in the one input (#817) that
+  // every other read in the process answers from, so the overlay that composes
+  // and the environment the artifact records can never be two different words.
+  // Same rule, same shape, in @omega.js/extension's getConfig.
+  const environment = Manager.getEnvironment();
 
   // No config at all (fresh dir, non-consumer cwd) → seeded empty shape below; the
   // schema validation in audit/boot reports what's actually missing.
   const cwd = process.cwd();
-  const config = hasOmegaConfig(cwd) ? loadConfig(cwd, 'desktop').config : {};
+  const config = hasOmegaConfig(cwd) ? loadConfig(cwd, 'desktop', { environment }).config : {};
+
+  // The environment rides ON the resolved config as the build fact every OMEGA
+  // surface spells the same way ([#896](https://github.com/Omega-JS-Stack/omega/issues/896)),
+  // so a dev boot loading config off disk hands main the same key a packaged
+  // app reads out of OMEGA_BUILD_JSON.
+  config.environment = environment;
 
   // Apply derived defaults. Always seed `brand` + `app` so callers can deref
   // `config.brand.X` / `config.app.X` without optional-chaining at every callsite.
   config.brand = config.brand || {};
   config.app   = config.app   || {};
   if (!config.app.appId) {
-    const host = String(config.brand.url || '').replace(/^https?:\/\//, '').replace(/^www\./, '').split('/')[0];
-    if (host) {
-      config.app.appId = host.split('.').reverse().join('.');
+    // The bundle-id policy is @omega.js/config's ONE derivation (#909): a
+    // config carrying an Apple prefix (its own, or the company layer's) signs
+    // under the very id the certificates service registers. The URL host is
+    // the fallback for a brand that declares no prefix, and a brand whose url
+    // is a code-host repo is why it cannot be the rule.
+    const prefix = config.certificates?.providers?.apple?.bundleIdPrefix;
+    const derived = deriveBundleIdPrefix(config.brand.url || '');
+
+    if (prefix && config.brand.id) {
+      config.app.appId = composeBundleId(prefix, config.brand.id);
+    } else if (derived) {
+      config.app.appId = derived;
     } else if (config.brand.id) {
       config.app.appId = `app.${config.brand.id}`;
     }
@@ -178,11 +219,11 @@ Manager.getLiveReloadPort = function () {
 };
 Manager.prototype.getLiveReloadPort = Manager.getLiveReloadPort;
 
-// Windows signing strategy. Config-only — `platforms.win.signing.strategy`
-// (targets.desktop.platforms.win in the raw omega.json5). Default 'self-hosted'.
+// Windows signing strategy. Config-only: `platforms.windows.signing.strategy`
+// (targets.desktop.platforms.windows in the raw omega.json5). Default 'self-hosted'.
 Manager.getWindowsSignStrategy = function () {
   const config = Manager.getConfig();
-  return config?.platforms?.win?.signing?.strategy || 'self-hosted';
+  return config?.platforms?.windows?.signing?.strategy || 'self-hosted';
 };
 Manager.prototype.getWindowsSignStrategy = Manager.getWindowsSignStrategy;
 

package/dist/cli-run.js

@@ -1,27 +1,34 @@
 /**
- * run() — the omega-desktop bin body, shared by bin/omega-desktop (via
- * dist/omega-bin.js) and cross-framework dispatch ('@omega.js/desktop/cli').
+ * run(): the CLI body, shared by bin/omega (via dist/omega-bin.js, the
+ * dispatcher) and cross-framework dispatch ('@omega.js/desktop/cli').
  */
+// The value-LESS flags, the only list a CLI owes the parse: every other flag
+// takes the next token as its value, which is what carries CI's own
+// `sign-windows --in release --out release/signed`. Mirrors the same fix in
+// @omega.js/backend's CLI.
+const BOOLEAN_FLAGS = [
+  'extended', 'local', 'quick', 'q', 'direct', 'dry-run', 'secrets',
+  'smoke', 'verify-only', 'find-window-id', 'publish', 'open', 'tail', 'f', 'strict',
+  'apply', 'major', 'force-fresh',
+];
+
 async function run() {
   // Local-dist freshness guard: a stale locally-linked dist rebuilds and the
   // invocation re-execs once, so no command ever runs stale framework code
   require('./vendor/devkit/local.js').freshnessBoot({ packageName: '@omega.js/desktop' });
 
+  // Boot preludes: the cheap, non-interactive checks every verb passes through,
+  // filtered by the verb about to run (#890)
+  require('./vendor/devkit/preludes/index.js').runPreludes({ verb: process.argv[2], targetDir: process.cwd() });
+
   // Strip ELECTRON_RUN_AS_NODE — it leaks into our env from common parent processes
   // (e.g. VS Code's Claude Code extension) and makes every Electron binary we shell
   // to silently run as plain Node. Strip once at the CLI boundary.
   delete process.env.ELECTRON_RUN_AS_NODE;
 
-  // Value-less flags must be declared boolean — otherwise yargs treats the next
-  // positional as the flag's VALUE. Mirrors the same fix in @omega.js/backend's CLI.
-  // yargs' built-in --version/--help are disabled so both route through the
-  // alias table / the router's built-in help (the built-ins printed an empty
-  // stub and version "0.0.0" — yargs can't resolve our package version here).
-  const argv = require('yargs')(process.argv.slice(2))
-    .boolean(['extended', 'local', 'quick', 'q'])
-    .version(false)
-    .help(false)
-    .parseSync();
+  // The router owns --help/--version, so both route through the alias table
+  // and the router's built-in help.
+  const argv = require('./vendor/devkit/argv.js').parseArgv(process.argv.slice(2), { booleans: BOOLEAN_FLAGS });
   const cli = new (require('./cli.js'))(argv);
 
   try {
@@ -31,4 +38,4 @@ async function run() {
   }
 }
 
-module.exports = { run };
+module.exports = { run, BOOLEAN_FLAGS };

package/dist/cli.js

@@ -4,24 +4,30 @@ const { createCliRouter } = require('./vendor/devkit/cli-router.js');
 const { isBoxVerbArgv } = require('./vendor/devkit/omega-bin.js');
 
 // Resolve the .env cascade from the project root
-// (shell > local .env > brand .env > company .env). The target name delivers
-// the schema's `deliverAs` renames into process.env (#678) — the brand's
-// GOOGLE_ANALYTICS_SECRET_DESKTOP arrives as GOOGLE_ANALYTICS_SECRET.
+// (shell > local .env > brand .env > company .env), then derive the signing
+// paths the brand's signing tree implies. The target name delivers the schema's
+// `deliverAs` renames into process.env (#678): the brand's
+// GOOGLE_ANALYTICS_SECRET_DESKTOP arrives as GOOGLE_ANALYTICS_SECRET. ONE
+// wrapper does both, here and in gulp ([#891](https://github.com/Omega-JS-Stack/omega/issues/891)),
+// so every verb after it reads the same CSC_LINK / APPLE_API_KEY answer.
 //
-// …for every verb but the signing box's. `runner` and `sign-windows` belong to
+// ...for every verb but the signing box's. `runner` and `sign-windows` belong to
 // a MACHINE, not a project: they read the shell and `<runner home>\.env` and
 // nothing else, so a brand's GH_TOKEN can never register the box's runners or
 // hand its release token to a config walk ([#337](https://github.com/Omega-JS-Stack/omega/issues/337)).
 // Which invocations those are is the dispatcher's own answer, imported: one
 // reading of it, covering the bare verb and its `--` flag spelling alike.
 if (!isBoxVerbArgv(process.argv.slice(2))) {
-  require('./vendor/config/index.js').loadEnv(process.cwd(), { target: 'desktop' });
+  require('./utils/load-env.js').loadDesktopEnv(process.cwd(), {
+    logger: new (require('./lib/logger.js'))('env'),
+  });
 }
 
 // Main class — dispatch (positional/flag alias resolution, command loading,
 // error surfacing) is the shared devkit router; this file owns only the alias
 // table and the commands directory. (ELECTRON_RUN_AS_NODE stripping stays in
-// the bin — it must happen before anything Electron-adjacent loads.)
+// cli-run.js, the bin body, and it must happen before anything
+// Electron-adjacent loads.)
 //
 // A bare `omega` prints help: setup is retired and every verb runs the local
 // scaffold itself ([#675](https://github.com/Omega-JS-Stack/omega/issues/675)).
@@ -41,7 +47,6 @@ module.exports = createCliRouter({
     logs:             ['--logs', 'log'],
     'validate-certs': ['certs', '--validate-certs'],
     'sign-windows':   ['--sign-windows'],
-    'push-secrets':   ['secrets', '--push-secrets'],
     'finalize-release': ['finalize', '--finalize-release'],
     runner:           ['--runner'],
     launch:           ['open', '--launch'],

package/dist/commands/build.js

@@ -6,13 +6,11 @@ const { ensureTarget } = require('./lib/ensure-target.js');
 
 // The consumer's `build` script is `omega build` — this verb owns the
 // pipeline and the build-mode flag; it must never shell back to that script.
-// `certs` delivers the Apple artifacts first (#678).
 function plan() {
   return {
     env: { OMEGA_BUILD_MODE: 'true' },
     steps: [
       { type: 'clean' },
-      { type: 'certs' },
       { type: 'gulp', task: 'build' },
     ],
   };

package/dist/commands/deploy.js

@@ -6,70 +6,142 @@
  * sending it; anything else delegates to release.
  *
  * Every run starts with the local scaffold the retired `omega setup` used to
- * own (ensureTarget, #675), delivers the Apple signing artifacts into the
- * target's certs dir (#678), and then runs setup's NETWORK half as a precheck:
- * framework freshness, cert validation, repo provisioning, secret publication.
- * `--no-secrets` skips that precheck.
+ * own (ensureTarget, #675). A DISPATCH then runs setup's NETWORK half as a
+ * precheck: framework freshness, cert validation, repo provisioning, secret
+ * publication. `--no-secrets` skips that precheck, and `--direct` never
+ * reaches it at all.
+ *
+ * `--direct` is the direct lane, asked for by a human
+ * ([#872](https://github.com/Omega-JS-Stack/omega/issues/872)): `omega publish
+ * --local` for THIS machine's platform. It used to select itself whenever the
+ * tree was linked, which took the CI lane away from the brands that need it
+ * most; a linked brand now packs its frameworks into the snapshot instead.
  */
-const { execSync } = require('node:child_process');
+const path = require('node:path');
 const Manager = new (require('../build.js'));
 const logger = Manager.logger('deploy');
-const { deployViaDispatch, findLocalSpecs } = require('../vendor/devkit/deploy.js');
+const attachLogFile = require('../utils/attach-log-file.js');
+const { assertBrandVersion } = require('../vendor/devkit/brand-version.js');
+const { targetNameFromDir } = require('../vendor/config/index.js');
 const { ensureTarget } = require('./lib/ensure-target.js');
 const { deployPrecheck } = require('./lib/deploy-precheck.js');
-const { deliverTargetCerts } = require('../utils/deliver-certs.js');
-const { dispatchTarget } = require('./release.js');
+const { desktopPlatform } = require('../utils/platform.js');
+const runConsumerHook = require('../utils/run-consumer-hook.js');
 
 module.exports = async function (options) {
   options = options || {};
   const dryRun = options.dryRun || options['dry-run'];
   const projectDir = process.cwd();
 
-  // The local half of the retired `omega setup` (#675), then the signing
-  // artifacts this target needs before anything signs (#678). Both are
-  // idempotent and quiet on a converged target.
+  // The whole verb goes to the target's own deploy log, from its first line
+  // ([#873](https://github.com/Omega-JS-Stack/omega/issues/873)): the scaffold,
+  // the precheck's refusals and the followed run all land in one file instead
+  // of scrollback. `omega release` attaches the same path, which is a no-op
+  // when this verb already did, and tees STACK, so a brand fan-out's log gets
+  // the same lines.
+  attachLogFile(path.join(projectDir, 'logs', 'deploy.log'));
+
+  // The local half of the retired `omega setup` (#675). Idempotent and quiet on
+  // a converged target. Nothing COPIES signing material any more: the tree is
+  // read in place and the env load derived the paths to it
+  // ([#891](https://github.com/Omega-JS-Stack/omega/issues/891)).
   await ensureTarget({ projectDir, log: (line) => logger.log(line), warn: (line) => logger.warn(line) });
-  deliverTargetCerts({ projectDir, logger });
 
-  // The NETWORK half, as a precheck: a deploy is the verb that needs the
-  // remote side right. A dry run sends nothing, so it prechecks nothing.
-  if (!dryRun) {
-    await deployPrecheck({ projectDir, options, logger });
+  // The brand's ONE version ([#869](https://github.com/Omega-JS-Stack/omega/issues/869)):
+  // a target whose version drifted from the brand root's is refused here, before
+  // the precheck, because a drifted target must not push its secrets and
+  // dispatch a build of the wrong number. A read, so every lane reaches it
+  // (`--direct` and `--dry-run` included).
+  assertBrandVersion({ dir: projectDir });
+
+  // The consumer's pre-deploy hook, on BOTH lanes and before anything is
+  // published or published to ([#899](https://github.com/Omega-JS-Stack/omega/issues/899)):
+  // the playground's prunes its release family down to the newest one.
+  // A dry run skips it, because a hook may act on the world and a dry run
+  // promises to send nothing.
+  if (dryRun) {
+    logger.log('DRY RUN, skipping hook "deploy/pre"');
+  } else {
+    // The one ctx shape every OMEGA hook takes, `{ manager, projectRoot, mode }`,
+    // and a deploy's mode is PRODUCTION: what it is about to publish is a release.
+    await runConsumerHook('deploy/pre', { manager: Manager, projectRoot: projectDir, mode: 'production' });
   }
 
-  // Linked local packages (tree-wide file: specs — cp194) → the LOCAL
-  // release flow automatically: build + sign + publish from this machine
-  // with the linked frameworks bundled in. Mirrored rule (Ian 2026-07-20);
-  // CI dispatch is only for registry-clean trees.
-  if (findLocalSpecs({ dir: process.cwd() }).length > 0) {
-    logger.log('Linked local packages detected — running the LOCAL release flow (build + sign + publish from this machine). CI dispatch resumes after `omega i live`.');
+  // The direct lane: build + sign + publish from THIS machine, for this
+  // machine's platform. A cross-platform build needs the runners CI has, so a
+  // `--platforms` naming anything else is refused rather than silently built
+  // for the host (#872).
+  //
+  // BEFORE the precheck, which belongs to the CI lane (web and backend already
+  // order it this way): a local deploy publishes nothing to the repo and needs
+  // no `gh` session, so pushing this target's signing certs into Actions
+  // secrets on the way past is exactly what it must not do (#872).
+  if (options.direct) {
+    const platform = directPlatform(options.platforms || options.platform);
+
     if (dryRun) {
-      logger.log('DRY RUN — would run: npm run release:local');
+      logger.log(`DRY RUN, would run: omega publish --local (${platform}, this machine)`);
       return;
     }
-    execSync('npm run release:local', { stdio: 'inherit' });
-    require('../vendor/devkit/deploy-record.js').recordDeploy({ dir: process.cwd(), target: 'desktop', detail: { method: 'local' } });
-    return logger.log('Deployed from the LOCAL release flow (linked frameworks included).');
-  }
 
-  if (dryRun) {
-    const platforms = options.platforms || options.platform || 'all';
-    // The SAME address `omega release` dispatches on (config, and the composed
-    // workflow name inside a brand), so the printed plan is the real one.
-    const target = dispatchTarget({ projectRoot: projectDir, config: Manager.getConfig() });
-    const { plan } = await deployViaDispatch({
-      workflow: target.workflow,
-      owner: target.owner,
-      repo: target.repo,
-      inputs: { platforms: String(platforms) },
-      dryRun: true,
-    });
-    logger.log('DRY RUN — would send:');
-    logger.log(`  ${plan.method} ${plan.url}`);
-    logger.log(`  body: ${JSON.stringify(plan.body)}`);
-    logger.log(`  then watch: ${plan.runsUrl}`);
-    return;
+    logger.log(`Building + publishing LOCALLY for ${platform} (signing credentials must be available on this machine)...`);
+    await require('./publish.js')({ ...options, local: true });
+    require('../vendor/devkit/deploy-record.js').recordDeploy({ dir: process.cwd(), target: targetNameFromDir(process.cwd()) || 'desktop', detail: { method: 'direct' } });
+    return logger.log(`Deployed from the LOCAL publish (${platform}).`);
   }
 
+  // The NETWORK half, as a precheck: the CI lane needs the remote side right
+  // (its secrets, its repos). A DRY RUN runs it too
+  // ([#895](https://github.com/Omega-JS-Stack/omega/issues/895)): every step is
+  // a read or a plan under `dryRun`, so the preview is the real one, refusals
+  // included.
+  await deployPrecheck({ projectDir, options, logger, dryRun });
+
+  // The dispatch lane, dry or not, is `omega release`: ONE call site on this
+  // target, so the previewed plan is the very one a real run sends, with the
+  // ref and the snapshot sha threaded exactly the same way. The preview used to
+  // build a second `deployViaDispatch` call here, which named neither.
   return require('./release.js')(options);
 };
+
+// What a `--platforms` value may say for each host, in OMEGA's own vocabulary
+// (#867): the platform NAME comes from the one translation point, and these are
+// the spellings the flag accepts for it. The workflow's `platforms` input speaks
+// the same three words.
+const HOST_PLATFORMS = {
+  mac: { accepts: ['mac'] },
+  windows: { accepts: ['windows'] },
+  linux: { accepts: ['linux'] },
+};
+
+/**
+ * The platform a `--direct` deploy builds: this machine's, and only this
+ * machine's. Electron cross-building (a signed Windows installer from a mac, a
+ * DMG from linux) is what the CI matrix exists for, so a `--platforms` naming
+ * anything but the host is an ERROR: building the host's platform instead
+ * would publish an artifact nobody asked for.
+ *
+ * @param {string} [platforms] - The `--platforms`/`--platform` value ('all', 'mac,linux', …).
+ * @param {string} [platform] - The host platform (defaults to process.platform).
+ * @returns {string} The host platform's workflow name ('mac' | 'windows' | 'linux').
+ * @throws {Error} When `platforms` names anything the host cannot build.
+ */
+function directPlatform(platforms, platform) {
+  const name = desktopPlatform(platform || process.platform);
+  const host = name && HOST_PLATFORMS[name];
+
+  if (!host) {
+    throw new Error(`Unsupported host platform for \`omega deploy --direct\`: ${platform || process.platform}. Dispatch the CI build instead (\`omega deploy\`).`);
+  }
+
+  const asked = String(platforms || name).toLowerCase().split(',').map((value) => value.trim()).filter(Boolean);
+  const foreign = asked.filter((value) => !host.accepts.includes(value));
+
+  if (foreign.length > 0) {
+    throw new Error(`\`omega deploy --direct\` builds on THIS machine, so it can only build ${name}: ${foreign.join(', ')} ${foreign.length === 1 ? 'is' : 'are'} CI-only. Run \`omega deploy\` (no --direct) to build every platform on the runners.`);
+  }
+
+  return name;
+}
+
+module.exports.directPlatform = directPlatform;

package/dist/commands/finalize-release.js

@@ -33,7 +33,7 @@ const logger = Manager.logger('finalize-release');
 
 module.exports = async function finalizeRelease(options = {}) {
   const argv = options._ || [];
-  // Parse flags from yargs-style options (yargs camelCases --signed-dir → signedDir).
+  // The parse mints both spellings of a kebab flag (--signed-dir, signedDir).
   const signedDir = options.signedDir || options['signed-dir'];
   const doPublish = options.publish === true;
 
@@ -59,10 +59,11 @@ module.exports = async function finalizeRelease(options = {}) {
   }
 
   // The releases repo (the auto-updater feed source), from config alone.
-  const { owner, name, repo } = releasesRepo(config);
-  if (!repo) {
-    throw new Error('finalize-release: could not address the releases repo. Set repo.providers.github.org (or targets.desktop.releases.owner) and brand.id in config/omega.json5.');
+  const releases = releasesRepo(config);
+  if (!releases) {
+    throw new Error('finalize-release: could not address the releases repo. Set repo.org and brand.id in config/omega.json5 (the releases repo is <brand.id>-releases under that org).');
   }
+  const { owner, name } = releases;
 
   const releaseTag = `v${pkgVersion}`;
 

package/dist/commands/launch.js

@@ -10,7 +10,7 @@
 //   honors by running as plain Node: no `app` API, no BrowserWindow, no window. The
 //   app exits cleanly with code 0 and no error. Total invisible silent failure.
 //
-//   `bin/omega-desktop` and `src/gulp/main.js` already strip ELECTRON_RUN_AS_NODE
+//   `src/cli-run.js` and `src/gulp/main.js` already strip ELECTRON_RUN_AS_NODE
 //   at the boundary so anything launched THROUGH mgr or gulp is fine. But the manual
 //   smoke-test flow (`open -n release/mac-arm64/MyApp.app`) bypasses both. This
 //   command is the manual-launch equivalent of those boundary strips.
@@ -21,7 +21,7 @@
 //   npx omega launch /Applications/MyApp.app                        # an installed .app
 //
 // Forwarding argv to the app (for hidden-mode tests, custom flags, etc.):
-//   npx omega launch --args="--omega-launched-at-login"                # single flag (quoted to keep yargs from eating it)
+//   npx omega launch --args="--omega-launched-at-login"                # single flag (quoted to keep the parse from eating it)
 //   npx omega launch --args="--foo=bar --baz"                       # multiple, space-separated inside the quotes
 //
 // Aliases: `npx omega open`, `npx omega --launch`.
@@ -62,8 +62,8 @@ module.exports = async function (options) {
   const childEnv = { ...process.env };
   delete childEnv.ELECTRON_RUN_AS_NODE;
 
-  // Forward extra argv to the app via `--args`. yargs splits the rest of argv into
-  // options._ when no flag matches; everything after the app path goes through.
+  // Forward extra argv to the app via `--args`. The parse puts every unmatched
+  // token in options._; everything after the app path goes through.
   const extraArgs = options._.slice(2);
   // Also accept --args as an explicit array/string.
   if (typeof options.args === 'string') extraArgs.push(...options.args.split(/\s+/).filter(Boolean));
@@ -79,7 +79,7 @@ module.exports = async function (options) {
     // routes to this instance for activate events). Pass extra argv via --args.
     cmd = 'open';
     args = ['-n', appPath, ...(extraArgs.length ? ['--args', ...extraArgs] : [])];
-    logHint = `open -n ${shellEscape(appPath)}${extraArgs.length ? ' --args ' + extraArgs.map(shellEscape).join(' ') : ''}`;
+    logHint = `open -n ${shellEscape(appPath)}${extraArgs.length ? ` --args ${extraArgs.map(shellEscape).join(' ')}` : ''}`;
   } else {
     // Direct binary launch — Windows .exe, Linux binary, or running the .app's MacOS
     // binary directly (rare, used to bypass LaunchServices for diagnosis).
@@ -88,7 +88,7 @@ module.exports = async function (options) {
       cmd = path.join(appPath, 'Contents', 'MacOS', path.basename(appPath, '.app'));
     }
     args = extraArgs;
-    logHint = `${shellEscape(cmd)}${args.length ? ' ' + args.map(shellEscape).join(' ') : ''}`;
+    logHint = `${shellEscape(cmd)}${args.length ? ` ${args.map(shellEscape).join(' ')}` : ''}`;
   }
 
   logger.log(`launching with clean env (ELECTRON_RUN_AS_NODE stripped)...`);
@@ -111,11 +111,16 @@ module.exports = async function (options) {
   logger.log('launched.');
 };
 
+// electron-builder's own output-dir words, keyed by OMEGA's (#867). This is the
+// ONE place the release dir's spelling is translated: `release/win-<arch>` is
+// electron-builder's name for the directory, not a platform OMEGA calls `win`.
+const RELEASE_DIRS = { mac: 'mac', windows: 'win', linux: 'linux' };
+
 // Auto-discover a packaged app under release/<platform>-<arch>/ — matches the output
 // directory of `mgr package:quick` for the host platform/arch.
 function autoDiscoverApp() {
   const projectRoot = process.cwd();
-  const platform    = process.platform === 'darwin' ? 'mac' : process.platform === 'win32' ? 'win' : 'linux';
+  const platform    = RELEASE_DIRS[require('../utils/platform.js').desktopPlatform()] || 'linux';
   const arch        = process.arch;
   const releaseDir  = path.join(projectRoot, 'release', `${platform}-${arch}`);