mixdog 1.1.0 → 1.1.2

package/README.md

@@ -12,8 +12,10 @@
   <a href="https://github.com/tribgames/mixdog/releases/latest/download/mixdog-desktop-win-x64.exe"><img src="https://raw.githubusercontent.com/tribgames/mixdog/main/docs/assets/download-windows.svg" alt="Download for Windows" height="48"></a>
   &nbsp;
   <a href="https://github.com/tribgames/mixdog/releases/latest/download/mixdog-desktop-mac-arm64.dmg"><img src="https://raw.githubusercontent.com/tribgames/mixdog/main/docs/assets/download-macos.svg" alt="Download for macOS" height="48"></a>
+  &nbsp;
+  <a href="https://github.com/tribgames/mixdog/releases/latest/download/mixdog-desktop-linux-x86_64.AppImage"><img src="https://raw.githubusercontent.com/tribgames/mixdog/main/docs/assets/download-linux.svg" alt="Download for Linux" height="48"></a>
   <br>
-  <sub>macOS button is for Apple Silicon (M1 and later). Intel Mac? <a href="https://github.com/tribgames/mixdog/releases/latest/download/mixdog-desktop-mac-x64.dmg">Download for Intel Mac</a></sub>
+  <sub>macOS button is for Apple Silicon (M1 and later). Intel Mac? <a href="https://github.com/tribgames/mixdog/releases/latest/download/mixdog-desktop-mac-x64.dmg">Download for Intel Mac</a>. Linux button is the x64 AppImage; .deb and ARM64 builds are listed below.</sub>
 </p>
 
 <p align="center">
@@ -35,9 +37,9 @@ https://github.com/user-attachments/assets/af515dc9-b0fb-4b6a-aaa1-1d82db792ed0
 - [63% fewer tokens](#benchmarks) than Codex CLI on the same model, at the
   same success rate.
 - [**Auto reasoning effort**](docs/auto-reasoning-effort.md) — each message
-  and tool step gets the effort it needs, judged in about 0.1 s by a 130 MB
+  and tool step gets the effort it needs, judged in about 0.1 s by a 150 MB
   model that runs locally on the CPU. On by default.
-- Use the **Claude, ChatGPT, or Grok** subscription you already have, API
+- Use the **Claude, ChatGPT, Grok, or Muse Code** subscription you already have, API
   keys, or local models on your own GPU.
 - Mix models by role and scale from **Solo to Swarm** — a strong model leads
   while cheaper ones search, edit, and review in parallel.
@@ -47,7 +49,7 @@ https://github.com/user-attachments/assets/af515dc9-b0fb-4b6a-aaa1-1d82db792ed0
   continues from your phone, end-to-end encrypted.
 - Goes beyond code with **browser and desktop control**, Office and PDF
   documents, and image and video generation.
-- Runs on Windows and macOS. No config files.
+- Runs on Windows, macOS, and Linux. No config files.
 
 ## Installation
 
@@ -58,8 +60,12 @@ Download the desktop app:
 | Windows (x64) | [`mixdog-desktop-win-x64.exe`](https://github.com/tribgames/mixdog/releases/latest/download/mixdog-desktop-win-x64.exe) |
 | macOS (Apple Silicon) | [`mixdog-desktop-mac-arm64.dmg`](https://github.com/tribgames/mixdog/releases/latest/download/mixdog-desktop-mac-arm64.dmg) |
 | macOS (Intel) | [`mixdog-desktop-mac-x64.dmg`](https://github.com/tribgames/mixdog/releases/latest/download/mixdog-desktop-mac-x64.dmg) |
+| Linux (x64, AppImage) | [`mixdog-desktop-linux-x86_64.AppImage`](https://github.com/tribgames/mixdog/releases/latest/download/mixdog-desktop-linux-x86_64.AppImage) |
+| Linux (x64, .deb) | [`mixdog-desktop-linux-amd64.deb`](https://github.com/tribgames/mixdog/releases/latest/download/mixdog-desktop-linux-amd64.deb) |
+| Linux (ARM64, AppImage) | [`mixdog-desktop-linux-arm64.AppImage`](https://github.com/tribgames/mixdog/releases/latest/download/mixdog-desktop-linux-arm64.AppImage) |
+| Linux (ARM64, .deb) | [`mixdog-desktop-linux-arm64.deb`](https://github.com/tribgames/mixdog/releases/latest/download/mixdog-desktop-linux-arm64.deb) |
 
-Then sign in with a ChatGPT, Claude, or Grok account, or paste an API key. A
+Then sign in with a ChatGPT, Claude, Grok, or Muse Code account, or paste an API key. A
 five-step tutorial walks you through the rest.
 
 > [!NOTE]
@@ -80,11 +86,12 @@ mixdog
 - OpenAI API keys and ChatGPT/Codex account OAuth
 - Google Gemini API keys
 - xAI API keys and Grok account OAuth
+- Muse Code (Meta) account OAuth
 - OpenRouter, DeepSeek, and OpenCode Go
 - Built-in **Local Provider** — download and run models in the app
   (Windows x64 with an NVIDIA GPU)
 
-Cursor and Antigravity (Gemini) OAuth are off by default under
+Cursor, Antigravity (Gemini), and MiMo OAuth are off by default under
 **Settings → Developer**; using them through OAuth risks account restrictions.
 
 </details>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "private": false,
   "type": "module",
   "description": "Open-source coding agent that matches Codex on Terminal-Bench 2.1 with 63% fewer tokens.",
@@ -203,7 +203,6 @@
     "eslint-scope": "^9.1.2",
     "lucide-static": "^1.41.0"
   },
-  "main": "index.js",
   "directories": {
     "doc": "docs"
   },

package/scripts/latest-guard.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+// Keep GitHub's "Latest" release on the newest published app release.
+// Run by .github/workflows/latest-guard.yml. When Latest points elsewhere (or
+// nowhere) it is set back with `gh release edit <tag> --latest`, the job
+// summary and an issue describe what was wrong, and the job fails so the
+// drift is visible even though it has been repaired.
+
+import { appendFileSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import { currentLatestTag, gh, listReleases, selectLatestAppRelease } from './release-guard.mjs';
+
+const ISSUE_TITLE = 'Latest release pointer drifted from the newest app release';
+
+function report(text) {
+  console.log(text);
+  if (process.env.GITHUB_STEP_SUMMARY) appendFileSync(process.env.GITHUB_STEP_SUMMARY, `${text}\n`);
+}
+
+function openIssue(repo, body) {
+  const existing = JSON.parse(gh([
+    'issue', 'list', '--repo', repo, '--state', 'open', '--search', `"${ISSUE_TITLE}" in:title`,
+    '--json', 'number,title',
+  ])).find((issue) => issue.title === ISSUE_TITLE);
+  if (existing) {
+    gh(['issue', 'comment', String(existing.number), '--repo', repo, '--body', body]);
+    return `commented on issue #${existing.number}`;
+  }
+  gh(['issue', 'create', '--repo', repo, '--title', ISSUE_TITLE, '--body', body]);
+  return 'opened an issue';
+}
+
+export function main(repo = process.env.GITHUB_REPOSITORY) {
+  const expected = selectLatestAppRelease(listReleases(repo));
+  if (!expected) {
+    report('No published app release (vX.Y.Z) exists; nothing to guard.');
+    return 0;
+  }
+  const actual = currentLatestTag(repo);
+  if (actual === expected.tag_name) {
+    report(`Latest is ${actual}, the newest app release. OK.`);
+    return 0;
+  }
+
+  const problem = `GitHub Latest was \`${actual ?? 'none'}\` but the newest published app release is \`${expected.tag_name}\`.`;
+  gh(['release', 'edit', expected.tag_name, '--repo', repo, '--latest']);
+  const repaired = currentLatestTag(repo);
+  const outcome = repaired === expected.tag_name
+    ? `Set Latest back to \`${expected.tag_name}\`.`
+    : `Could not set Latest to \`${expected.tag_name}\`; it is now \`${repaired ?? 'none'}\`.`;
+  const detail = `${problem}\n${outcome}\n\nWorkflow run: ${process.env.GITHUB_SERVER_URL ?? ''}/${repo}/actions/runs/${process.env.GITHUB_RUN_ID ?? ''}\n`
+    + 'Check which release or workflow published a non-app release without `--latest=false` / `make_latest: false`.';
+  report(`## Latest release guard\n${detail}`);
+  try {
+    report(`Issue: ${openIssue(repo, detail)}.`);
+  } catch (error) {
+    report(`Issue not filed: ${error.message}`);
+  }
+  return 1;
+}
+
+if (process.argv[1] && pathToFileURL(process.argv[1]).href === import.meta.url) {
+  process.exit(main());
+}

package/scripts/lib/run-node-tests.mjs

@@ -70,19 +70,68 @@ const positiveInt = (value) => {
 // `node --test` defaults to availableParallelism()-1 file processes. When the
 // run is one of several concurrent shell commands (the Mixdog shell tool
 // exports the admission cap as MIXDOG_SHELL_CONCURRENCY_CAP), that multiplies
-// across peers, so each run takes its share of the cores. Precedence: an
+// across peers, so a capped run leaves `cap` cores to them: cores - cap, never
+// below 4. Dividing the cores by the cap left a 20-core machine with 2 file
+// processes and tripled the wall time (desktop 289 s vs 63.5 s). Precedence: an
 // explicit --test-concurrency flag, then MIXDOG_TEST_CONCURRENCY, then the
-// share; with none of them Node's default stands and standalone runs are
-// unchanged. Returns the flag to add, or null.
+// capped share; with none of them Node's default (cores-1) stands.
+// Returns the flag to add, or null.
 export function testConcurrencyArg(nodeArgs, env = process.env, parallelism = availableParallelism()) {
-  if (nodeArgs.some((arg) => arg === '--test-concurrency' || arg.startsWith('--test-concurrency='))) return null;
+  if (nodeArgs.some(concurrencyFlag)) return null;
   const explicit = positiveInt(env.MIXDOG_TEST_CONCURRENCY);
   if (explicit) return `--test-concurrency=${explicit}`;
   const cap = positiveInt(env.MIXDOG_SHELL_CONCURRENCY_CAP);
   if (!cap) return null;
-  return `--test-concurrency=${Math.max(2, Math.floor(parallelism / cap))}`;
+  return `--test-concurrency=${Math.max(4, parallelism - cap)}`;
 }
 
+// Every test file process is bounded: node:test fails a file (and records it
+// like any other failure) that is still running after --test-timeout, so a hang
+// costs minutes instead of waiting for the batch watchdog. A --test-timeout
+// flag wins, then MIXDOG_TEST_TIMEOUT_MS (0 turns the bound off), then the
+// caller's default. Returns the flag to add, or null.
+export function testTimeoutArg(nodeArgs, env = process.env, defaultMs = DEFAULT_TEST_TIMEOUT_MS) {
+  if (nodeArgs.some((arg) => arg === '--test-timeout' || arg.startsWith('--test-timeout='))) return null;
+  const raw = env.MIXDOG_TEST_TIMEOUT_MS;
+  if (raw !== undefined && String(raw).trim() === '0') return null;
+  const ms = positiveInt(raw) ?? defaultMs;
+  return ms ? `--test-timeout=${ms}` : null;
+}
+
+const concurrencyFlag = (arg) => arg === '--test-concurrency' || arg.startsWith('--test-concurrency=');
+
+// The file-process count a run was given (flag or env), else Node's default.
+function concurrencyOf(runArgs, fileArgs) {
+  const args = [...runArgs, ...fileArgs];
+  const index = args.findIndex(concurrencyFlag);
+  const value = index < 0 ? null : positiveInt(args[index].includes('=') ? args[index].split('=')[1] : args[index + 1]);
+  return value ?? Math.max(1, availableParallelism() - 1);
+}
+
+function withoutConcurrency(args) {
+  return args.filter((arg, i) => !concurrencyFlag(arg) && !(i > 0 && args[i - 1] === '--test-concurrency'));
+}
+
+// What keeps a test process off the signed-in user's machine state.
+export function testIsolationEnv(scratchDir) {
+  return {
+    TEMP: scratchDir,
+    TMP: scratchDir,
+    TMPDIR: scratchDir,
+    // A fixture must never write into the signed-in app's data (~/.mixdog):
+    // schedule/webhook logs, design-library bindings and the like resolve the
+    // default data dir. The desktop preload already does this per process.
+    MIXDOG_DATA_DIR: join(scratchDir, 'data'),
+    // Any session a test composes would otherwise read the real home's
+    // AGENTS.md / CLAUDE.md whenever the stored setting is on; tests that
+    // exercise the feature clear this and pass their own home.
+    MIXDOG_BOOT_INSTRUCTION_FILES: '0',
+  };
+}
+
+export const DEFAULT_TEST_TIMEOUT_MS = 120_000;
+export const LONG_TEST_TIMEOUT_MS = 600_000;
+
 // A batch that has not exited by then is killed with its process tree and
 // fails the run; MIXDOG_TEST_BATCH_TIMEOUT_MS overrides the default.
 const DEFAULT_BATCH_TIMEOUT_MS = 60 * 60 * 1000;
@@ -185,8 +234,11 @@ export function ownedProcesses(snapshot, anchors, { batchStart, scratchDir, plat
     }
   }
   const fold = (path) => (platform === 'win32' ? path.toLowerCase() : path);
-  const scratchPrefix = fold(join(scratchDir, '/'));
-  for (const entry of snapshot) if (entry.exe && fold(entry.exe).startsWith(scratchPrefix)) claim(entry);
+  // An empty scratchDir skips the sweep: batches running side by side share
+  // one scratch root, so one batch's exit must not claim its peers' processes.
+  const scratchPrefix = scratchDir ? fold(join(scratchDir, '/')) : null;
+  if (scratchPrefix)
+    for (const entry of snapshot) if (entry.exe && fold(entry.exe).startsWith(scratchPrefix)) claim(entry);
   while (queue.length > 0) {
     const parent = queue.pop();
     for (const entry of childrenOf.get(parent.pid) ?? []) {
@@ -219,6 +271,10 @@ async function reapLeftovers(child, { batchStart, ledger, scratchDir }) {
     }
   }
   const anchors = [...(child.pid ? [{ pid: child.pid, since: batchStart }] : []), ...(await readSpawnLedger(ledger))];
+  await killOwned(anchors, { batchStart, scratchDir });
+}
+
+async function killOwned(anchors, { batchStart, scratchDir }) {
   const leftovers = ownedProcesses(await processSnapshot(), anchors, { batchStart, scratchDir });
   if (leftovers.length === 0) return;
   const pids = leftovers.map((entry) => entry.pid);
@@ -237,6 +293,7 @@ async function reapLeftovers(child, { batchStart, ledger, scratchDir }) {
 }
 
 // Resolves { code, hung } once the batch exited and its leftovers are gone.
+// `scratchDir` '' = leave the scratch-root sweep to the caller (side-by-side batches).
 function spawnBatch(args, env, { files, ledger, scratchDir, timeoutMs }) {
   return new Promise((resolve) => {
     const batchStart = Date.now();
@@ -313,10 +370,12 @@ async function readFailureRecords(path) {
 // flag was passed, does not fail the run; a test that fails every re-run
 // still exits 1. Every run ends with the failure summary block, so a filtered
 // log can still name what failed.
+//
+// `testTimeoutMs` is the per-file --test-timeout default (see testTimeoutArg).
 export async function runNodeTests(
   nodeArgs,
   fileArgs,
-  { argBudget = ARG_BUDGET, coverage = false, rerunFailed = 0 } = {}
+  { argBudget = ARG_BUDGET, coverage = false, rerunFailed = 0, testTimeoutMs = DEFAULT_TEST_TIMEOUT_MS } = {}
 ) {
   await pruneStaleTestLogs(tmpdir());
   const logPath = join(await mkdtemp(join(tmpdir(), TEST_LOG_PREFIX)), 'full.log');
@@ -330,9 +389,11 @@ export async function runNodeTests(
   const scratchDir = await mkdtemp(join(tmpdir(), 'mixdog-test-scratch-'));
   // The explicit entry also accepts Node options alongside its file paths.
   const concurrencyArg = testConcurrencyArg([...nodeArgs, ...fileArgs]);
+  const timeoutArg = testTimeoutArg([...nodeArgs, ...fileArgs], process.env, testTimeoutMs);
   const runArgs = [
     ...nodeArgs,
     ...(concurrencyArg ? [concurrencyArg] : []),
+    ...(timeoutArg ? [timeoutArg] : []),
     // Node's test runner passes --import on to every test file process.
     `--import=${SPAWN_LEDGER}`,
     `--test-reporter=${SUMMARY_REPORTER}`,
@@ -343,8 +404,19 @@ export async function runNodeTests(
     argCost(process.execPath) +
     runArgs.reduce((total, arg) => total + argCost(arg), 0) +
     argCost(`--test-reporter-destination=${logPath}`) +
-    argCost('.999'); // the per-batch log suffix
+    argCost('.999') + // the per-batch log suffix
+    argCost('--test-concurrency=999'); // the per-batch share when batches overlap
   const batches = chunkFileArgs(fileArgs, Math.max(argBudget - fixedCost, 1));
+  // Batches run side by side (a sequential second batch idled the machine
+  // behind the first one's slowest file), so the run's concurrency is split
+  // across them instead of multiplied.
+  const overlapped = batches.length > 1;
+  const totalConcurrency = overlapped ? concurrencyOf(runArgs, fileArgs) : 0;
+  const batchRunArgs = () => {
+    if (!overlapped) return runArgs;
+    const share = Math.max(1, Math.ceil(totalConcurrency / batches.length));
+    return [...withoutConcurrency(runArgs), `--test-concurrency=${share}`];
+  };
   const coverageDir = coverage ? await mkdtemp(join(tmpdir(), 'mixdog-v8-coverage-')) : '';
   // Node 24's test runner rebuilds each test process's execArgv from its option
   // table and drops V8 flags on the way, so a heap cap passed to the runner no
@@ -356,13 +428,7 @@ export async function runNodeTests(
   // already budgeted, and a third reporter would warn about listeners.
   const childEnv = (recordsPath) => ({
     ...process.env,
-    TEMP: scratchDir,
-    TMP: scratchDir,
-    TMPDIR: scratchDir,
-    // A fixture must never write into the signed-in app's data (~/.mixdog):
-    // schedule/webhook logs, design-library bindings and the like resolve the
-    // default data dir. The desktop preload already does this per process.
-    MIXDOG_DATA_DIR: join(scratchDir, 'data'),
+    ...testIsolationEnv(scratchDir),
     // Only the immutable validator binary is shared; fixture data stays private.
     // A gate supplies one directory across lanes; a standalone run owns its own.
     MIXDOG_TEST_OOXML_CACHE_DIR: process.env.MIXDOG_TEST_OOXML_CACHE_DIR || join(scratchDir, 'ooxml-cache'),
@@ -370,23 +436,33 @@ export async function runNodeTests(
     ...(coverageDir ? { NODE_V8_COVERAGE: coverageDir } : {}),
     ...(nodeOptions ? { NODE_OPTIONS: nodeOptions } : {}),
   });
-  const batchOptions = (files, recordsPath) => ({
+  const batchOptions = (files, recordsPath, sweepScratch = true) => ({
     files,
     ledger: spawnLedgerPath(recordsPath),
-    scratchDir,
+    scratchDir: sweepScratch ? scratchDir : '',
     timeoutMs: positiveInt(process.env.MIXDOG_TEST_BATCH_TIMEOUT_MS) ?? DEFAULT_BATCH_TIMEOUT_MS,
   });
   let status = 0;
   const failures = [];
   const hung = [];
-  for (const [index, batch] of batches.entries()) {
-    const batchLog = batches.length === 1 ? logPath : `${logPath}.${index + 1}`;
-    const batchFailures = join(failureDir, `batch-${index + 1}.jsonl`);
-    const outcome = await spawnBatch(
-      [...runArgs, `--test-reporter-destination=${batchLog}`, ...batch],
-      childEnv(batchFailures),
-      batchOptions(batch, batchFailures)
-    );
+  const batchLogOf = (index) => (batches.length === 1 ? logPath : `${logPath}.${index + 1}`);
+  const batchFailuresOf = (index) => join(failureDir, `batch-${index + 1}.jsonl`);
+  const outcomes = await Promise.all(
+    batches.map((batch, index) =>
+      spawnBatch(
+        [...batchRunArgs(), `--test-reporter-destination=${batchLogOf(index)}`, ...batch],
+        childEnv(batchFailuresOf(index)),
+        batchOptions(batch, batchFailuresOf(index), !overlapped)
+      )
+    )
+  );
+  // Peers were still running while each batch exited, so the scratch root's
+  // own processes (e.g. a postgres a test started) are swept once, here.
+  if (overlapped) await killOwned([], { batchStart: Date.now(), scratchDir });
+  // Logs and records merge in batch order, whatever order the batches finished.
+  for (const [index, outcome] of outcomes.entries()) {
+    const batchLog = batchLogOf(index);
+    const batchFailures = batchFailuresOf(index);
     const { code } = outcome;
     if (outcome.hung) hung.push(outcome.hung);
     if (batchLog !== logPath) {
@@ -443,5 +519,5 @@ export async function runNodeTests(
     await rm(coverageDir, { recursive: true, force: true });
   }
   // Last line of the run, after every reporter and the coverage report.
-  process.stdout.write(`\n${formatFailureSummary({ failed, flaky, rerunFailed, hung })}`);
+  process.stdout.write(`\n${formatFailureSummary({ failed, flaky, rerunFailed, hung, exitCode: status })}`);
 }

package/scripts/lib/test-failure-summary.mjs

@@ -45,10 +45,15 @@ export function policyLine(rerunFailed) {
 
 // `hung` holds one "hung after N min: <files>" message per batch the runner's
 // watchdog killed; such a batch fails the run whatever its tests reported.
-export function formatFailureSummary({ failed = [], flaky = [], rerunFailed = 0, hung = [] }) {
+// A non-zero `exitCode` with no failed test, flaky test or hung batch behind it
+// (a bad node flag, a crashed runner) is its own failure, never "0 failed".
+export function formatFailureSummary({ failed = [], flaky = [], rerunFailed = 0, hung = [], exitCode = 0 }) {
   const hungCount = hung.length > 0 ? `, ${hung.length} hung batch(es)` : '';
+  const unexplained = exitCode !== 0 && failed.length === 0 && hung.length === 0;
   const lines = [
-    `${SUMMARY_TAG} ${failed.length} failed, ${flaky.length} flaky${hungCount} (every failed test is named below)`,
+    unexplained
+      ? `${SUMMARY_TAG} RUN FAILED: exit code ${exitCode} with no failed test recorded (bad argument or runner error; see output above)`
+      : `${SUMMARY_TAG} ${failed.length} failed, ${flaky.length} flaky${hungCount} (every failed test is named below)`,
   ];
   for (const message of hung) lines.push(`${SUMMARY_TAG} HUNG ${message}`);
   for (const record of failed) {

package/scripts/merge-mac-update-feed.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+// electron-builder writes one latest-mac.yml per macOS build, and each runner
+// builds a single architecture, so each feed lists only its own zip and dmg.
+// electron-updater on macOS always reads the single latest-mac.yml of the
+// latest release and picks the zip whose name matches the machine's
+// architecture, so the release needs one feed that lists both builds.
+//
+// The publish job runs without installing dependencies, so this reads the
+// fixed shape electron-builder emits (top-level scalars plus a `files:` list
+// of `- url:` items) directly and fails on anything else.
+
+import { readFileSync, writeFileSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+
+export const MAC_ARCHES = Object.freeze(['arm64', 'x64']);
+// Legacy top-level path/sha512 (read only by electron-updater 1.x) point at
+// the x64 zip, which also runs on Apple silicon through Rosetta.
+const PRIMARY_ARCH = 'x64';
+const TOP_LEVEL_KEYS = ['version', 'path', 'sha512', 'releaseDate'];
+
+function zipArch(url) {
+  const match = /^mixdog-desktop-mac-([a-z0-9]+)\.zip$/.exec(url);
+  return match ? match[1] : null;
+}
+
+/** Parse one electron-builder latest-mac.yml. File items keep their raw lines. */
+export function parseMacFeed(text, label) {
+  const top = {};
+  const files = [];
+  let inFiles = false;
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    if (/^\S/.test(line)) {
+      const match = /^([A-Za-z][A-Za-z0-9]*):(?:\s+(.*))?$/.exec(line);
+      if (!match) throw new Error(`${label}: unsupported line: ${line}`);
+      inFiles = match[1] === 'files';
+      if (!inFiles) top[match[1]] = line;
+    } else if (inFiles && /^ {2}- url: \S+$/.test(line)) {
+      files.push({ url: line.replace(/^ {2}- url:\s+/, ''), lines: [line] });
+    } else if (inFiles && files.length > 0 && /^ {4}[A-Za-z][A-Za-z0-9]*: \S.*$/.test(line)) {
+      files[files.length - 1].lines.push(line);
+    } else {
+      throw new Error(`${label}: unsupported line: ${line}`);
+    }
+  }
+  for (const key of TOP_LEVEL_KEYS) {
+    if (!top[key]) throw new Error(`${label}: missing ${key}`);
+  }
+  const value = (key) => top[key].slice(key.length + 1).trim();
+  return { version: value('version'), top, files };
+}
+
+/** Merge the per-architecture feeds into one feed listing both zips. */
+export function mergeMacFeeds(inputs, expectedVersion) {
+  const feeds = inputs.map(({ label, text }) => {
+    const feed = parseMacFeed(text, label);
+    if (expectedVersion && feed.version !== expectedVersion) {
+      throw new Error(`${label}: version ${feed.version} is not ${expectedVersion}`);
+    }
+    const zips = feed.files.filter((file) => zipArch(file.url));
+    if (zips.length !== 1) throw new Error(`${label}: expected exactly one mac zip, found ${zips.length}`);
+    const [zip] = zips;
+    for (const field of ['sha512', 'size']) {
+      if (!zip.lines.some((line) => line.startsWith(`    ${field}: `))) {
+        throw new Error(`${label}: ${zip.url} has no ${field}`);
+      }
+    }
+    return { ...feed, arch: zipArch(zip.url) };
+  });
+  const arches = feeds.map((feed) => feed.arch).sort();
+  if (JSON.stringify(arches) !== JSON.stringify(MAC_ARCHES)) {
+    throw new Error(`Expected one feed per ${MAC_ARCHES.join(' + ')}, found: ${arches.join(', ')}`);
+  }
+  if (feeds[0].version !== feeds[1].version) {
+    throw new Error(`Feed versions differ: ${feeds[0].version} and ${feeds[1].version}`);
+  }
+  feeds.sort((a, b) => MAC_ARCHES.indexOf(a.arch) - MAC_ARCHES.indexOf(b.arch));
+  const entries = feeds.flatMap((feed) => feed.files);
+  const urls = entries.map((file) => file.url);
+  if (new Set(urls).size !== urls.length) throw new Error(`Duplicate feed files: ${urls.join(', ')}`);
+  const primary = feeds.find((feed) => feed.arch === PRIMARY_ARCH);
+  return [
+    primary.top.version,
+    'files:',
+    ...entries.flatMap((file) => file.lines),
+    primary.top.path,
+    primary.top.sha512,
+    primary.top.releaseDate,
+    '',
+  ].join('\n');
+}
+
+if (process.argv[1] && pathToFileURL(process.argv[1]).href === import.meta.url) {
+  const args = process.argv.slice(2);
+  const option = (name) => args.find((arg) => arg.startsWith(`--${name}=`))?.slice(name.length + 3);
+  const out = option('out');
+  const inputs = args.filter((arg) => !arg.startsWith('--'));
+  if (!out || inputs.length === 0) {
+    throw new Error('usage: merge-mac-update-feed.mjs --out=latest-mac.yml [--version=X.Y.Z] <feed.yml>...');
+  }
+  const merged = mergeMacFeeds(
+    inputs.map((path) => ({ label: path, text: readFileSync(path, 'utf8') })),
+    option('version')
+  );
+  writeFileSync(out, merged);
+  console.log(`Wrote ${out} from ${inputs.length} feeds.`);
+}