amalgm 0.1.139 → 0.1.140

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.139",
+  "version": "0.1.140",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,

package/runtime/scripts/amalgm-mcp/events/desktop-release-runner.js

@@ -713,8 +713,6 @@ function envForBuild(
     AMALGM_DESKTOP_RUNTIME_DELIVERY: desktopRuntimeDelivery(baseEnv),
     ...(desktopRendererDelivery(baseEnv) === 'bundled-next' ? {
       NEXT_IMAGE_UNOPTIMIZED: '1',
-      NEXT_PUBLIC_SUPABASE_URL: '',
-      NEXT_PUBLIC_SUPABASE_ANON_KEY: '',
     } : {}),
     AMALGM_RUNTIME_LABEL: request.lane === 'preview' ? 'preview' : 'main',
     AMALGM_BRANCH: request.lane,
@@ -916,6 +914,41 @@ function updateChannelArtifactDigest(channelPath, filePath) {
   }));
 }
 
+function readChannelInfo(channelPath) {
+  if (!channelPath) return null;
+  const raw = fs.readFileSync(channelPath, 'utf8');
+  const info = yaml.load(raw);
+  if (!info || typeof info !== 'object' || Array.isArray(info)) {
+    throw new Error(`Desktop release channel file is not a YAML object: ${channelPath}`);
+  }
+  return info;
+}
+
+function descriptorForChannelArtifact(channelInfo, kind) {
+  if (!channelInfo || typeof channelInfo !== 'object' || Array.isArray(channelInfo)) return null;
+  const extension = kind === 'zip' ? '.zip' : '.dmg';
+  const files = Array.isArray(channelInfo.files) ? channelInfo.files : [];
+  const match = files.find((file) => (
+    file
+    && typeof file === 'object'
+    && !Array.isArray(file)
+    && cleanString(file.url).endsWith(extension)
+  ));
+  if (!match) return null;
+
+  const artifact = cleanString(match.url);
+  const size = Number(match.size);
+  const sha512 = cleanString(match.sha512);
+  if (!artifact || !sha512 || !Number.isFinite(size) || size <= 0) return null;
+  return {
+    platform: 'macos',
+    kind,
+    artifact,
+    size,
+    sha512,
+  };
+}
+
 function regenerateArtifactBlockmap(engineDir, artifactPath, env = process.env) {
   const blockmapPath = `${artifactPath}.blockmap`;
   run(appBuilderBinaryPath(engineDir, env), [
@@ -1433,7 +1466,10 @@ function publishLegacyGithubBridgeRelease({
   }
 }
 
-function desktopReleaseMetadata({ tag, version, request, refs, shas, sourcePackageVersion, publishTarget, artifacts }) {
+function desktopReleaseMetadata({ tag, version, request, refs, shas, sourcePackageVersion, publishTarget, artifacts, channelPath }) {
+  const channelInfo = readChannelInfo(channelPath);
+  const primaryDownload = descriptorForChannelArtifact(channelInfo, 'dmg');
+  const updateArtifact = descriptorForChannelArtifact(channelInfo, 'zip');
   return {
     provider: publishTarget.provider,
     updateProvider: publishTarget.updateProvider,
@@ -1451,6 +1487,8 @@ function desktopReleaseMetadata({ tag, version, request, refs, shas, sourcePacka
     sourceRunId: request.delivery || `amalgm-automation-${version}`,
     artifacts: artifacts.map((filePath) => path.basename(filePath)),
     publishedAt: new Date().toISOString(),
+    ...(primaryDownload ? { primaryDownload } : {}),
+    ...(updateArtifact ? { updateArtifact } : {}),
   };
 }
 
@@ -1768,8 +1806,6 @@ function publishDesktopRelease(request, options = {}) {
       env: {
         ...releaseEnv,
         NEXT_IMAGE_UNOPTIMIZED: '1',
-        NEXT_PUBLIC_SUPABASE_URL: '',
-        NEXT_PUBLIC_SUPABASE_ANON_KEY: '',
       },
     });
   }
@@ -1812,7 +1848,17 @@ function publishDesktopRelease(request, options = {}) {
     releaseUrl = `https://github.com/${releaseRepository.fullName}/releases/tag/${tag}`;
     legacyBridge = desktopLegacyBridgePlan(buildEnv, publishTarget);
   } else {
-    const metadata = desktopReleaseMetadata({ tag, version, request, refs, shas, sourcePackageVersion, publishTarget, artifacts });
+    const metadata = desktopReleaseMetadata({
+      tag,
+      version,
+      request,
+      refs,
+      shas,
+      sourcePackageVersion,
+      publishTarget,
+      artifacts,
+      channelPath,
+    });
     uploadFlyReleaseAssets({ artifactPaths: artifacts, cwd: engineDir, env: buildEnv, publishTarget, metadata });
     legacyBridge = publishLegacyGithubBridgeRelease({
       tag,
@@ -1884,6 +1930,7 @@ module.exports = {
   desktopReleaseProvider,
   desktopReleasePublishTarget,
   desktopReleaseToolEnv,
+  desktopReleaseMetadata,
   desktopUpdateUrlForLane,
   desktopVersion,
   desktopReleaseArtifactPaths,

package/runtime/scripts/amalgm-mcp/lib/prefs.js

@@ -344,6 +344,22 @@ function normalizeModelSettings(value) {
   return normalized;
 }
 
+function normalizeAgentPreferences(value) {
+  if (!isPlainObject(value)) return {};
+  const normalized = {};
+  for (const [selectionId, preference] of Object.entries(value)) {
+    if (!selectionId || !isPlainObject(preference)) continue;
+    const modelSettings = normalizeModelSettings({ [selectionId]: preference.modelSettings })[selectionId];
+    normalized[selectionId] = {
+      ...(cleanString(preference.harness) ? { harness: cleanString(preference.harness) } : {}),
+      ...(cleanString(preference.model) ? { model: cleanString(preference.model) } : {}),
+      ...(cleanString(preference.authMethod) ? { authMethod: cleanString(preference.authMethod) } : {}),
+      ...(modelSettings ? { modelSettings } : {}),
+    };
+  }
+  return normalized;
+}
+
 function normalizeReasoningEffort(value) {
   if (typeof value !== 'string') return null;
   const normalized = value.trim().toLowerCase().replace(/_/g, '-');
@@ -422,6 +438,7 @@ function normalizePreferences(input) {
 
   const rawLastUsed = isPlainObject(raw.last_used) ? raw.last_used : {};
   const lastUsedHarness = coerceHarnessId(rawLastUsed.harness, 'claude_code');
+  const lastUsedAgent = cleanString(rawLastUsed.agent) || lastUsedHarness;
   const rawLastModel =
     rawLastUsed.model ||
     recentPrefs[lastUsedHarness] ||
@@ -429,10 +446,13 @@ function normalizePreferences(input) {
   const lastUsedModel =
     normalizeModelSelection(lastUsedHarness, rawLastModel).modelId ||
     rawLastModel;
-  recentPrefs[lastUsedHarness] = lastUsedModel;
+  if (lastUsedAgent === lastUsedHarness) {
+    recentPrefs[lastUsedHarness] = lastUsedModel;
+  }
 
   return {
     last_used: {
+      agent: lastUsedAgent,
       harness: lastUsedHarness,
       model: lastUsedModel,
       cwd: normalizePreferenceCwd(rawLastUsed.cwd ?? raw.last_cwd ?? raw.selected_cwd),
@@ -440,6 +460,7 @@ function normalizePreferences(input) {
     usage,
     recent_prefs: recentPrefs,
     model_settings: normalizeModelSettings(raw.model_settings),
+    agent_preferences: normalizeAgentPreferences(raw.agent_preferences),
   };
 }
 
@@ -510,6 +531,10 @@ function mergePreferencesPatch(current, patch) {
     bodyLastUsed.harness,
     current.last_used.harness,
   );
+  const lastUsedAgent =
+    cleanString(bodyLastUsed.agent)
+    || current.last_used.agent
+    || lastUsedHarness;
   const bodyRecentPrefs = isPlainObject(body.recent_prefs) ? body.recent_prefs : {};
   const recentPrefs = {
     ...current.recent_prefs,
@@ -528,6 +553,7 @@ function mergePreferencesPatch(current, patch) {
 
   return normalizePreferences({
     last_used: {
+      agent: lastUsedAgent,
       harness: lastUsedHarness,
       model: lastUsedModel,
       cwd,
@@ -537,6 +563,7 @@ function mergePreferencesPatch(current, patch) {
       : current.usage,
     recent_prefs: recentPrefs,
     model_settings: mergeModelSettingsPatch(current.model_settings, body.model_settings),
+    agent_preferences: mergeAgentPreferencesPatch(current.agent_preferences, body.agent_preferences),
   });
 }
 
@@ -553,6 +580,29 @@ function mergeModelSettingsPatch(currentModelSettings, patchModelSettings) {
   return next;
 }
 
+function mergeAgentPreferencesPatch(currentAgentPreferences, patchAgentPreferences) {
+  if (!isPlainObject(patchAgentPreferences)) return currentAgentPreferences;
+  const next = normalizeAgentPreferences(currentAgentPreferences);
+  for (const [selectionId, value] of Object.entries(patchAgentPreferences)) {
+    if (!isPlainObject(value)) continue;
+    const current = isPlainObject(next[selectionId]) ? { ...next[selectionId] } : {};
+    if (Object.prototype.hasOwnProperty.call(value, 'modelSettings')) {
+      delete current.modelSettings;
+    }
+    if (Object.prototype.hasOwnProperty.call(value, 'model') && !cleanString(value.model)) {
+      delete current.model;
+    }
+    if (Object.prototype.hasOwnProperty.call(value, 'authMethod') && !cleanString(value.authMethod)) {
+      delete current.authMethod;
+    }
+    next[selectionId] = {
+      ...current,
+      ...normalizeAgentPreferences({ [selectionId]: value })[selectionId],
+    };
+  }
+  return next;
+}
+
 function updateUserPreferences(patch, options = {}) {
   const current = readUserPreferences();
   return writeUserPreferences(mergePreferencesPatch(current, patch), options);

package/runtime/scripts/amalgm-mcp/server/routes/preferences.js

@@ -9,7 +9,7 @@ async function handlePreferenceRoutes(ctx) {
   }
   if (ctx.pathname === '/user-preferences' && ctx.method === 'PUT') {
     const preferences = prefsStore.updateUserPreferences(await ctx.readJsonBody());
-    ctx.sendJson(200, { success: true, preferences });
+    ctx.sendJson(200, preferences);
     return true;
   }
   return false;

package/runtime/scripts/amalgm-mcp/tests/agents-source-of-truth.test.js

@@ -10,7 +10,7 @@ const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-agents-source-tes
 process.env.AMALGM_DIR = path.join(tempRoot, '.amalgm');
 
 const { closeLocalDb } = require('../state/db');
-const { writeUserPreferences } = require('../lib/prefs');
+const { readUserPreferences, updateUserPreferences, writeUserPreferences } = require('../lib/prefs');
 const {
   createAgent,
   getAllAgentsWithBuiltins,
@@ -81,6 +81,57 @@ test('custom agent auth and model settings survive normalization', () => {
   assert.equal(Object.prototype.hasOwnProperty.call(agent, 'tools'), false);
 });
 
+test('user preferences preserve the last-used custom agent selection across patches', () => {
+  writeUserPreferences({
+    last_used: {
+      agent: 'custom-review-agent',
+      harness: 'codex',
+      model: 'openai/gpt-5.5',
+      cwd: tempRoot,
+    },
+  });
+
+  updateUserPreferences({
+    last_used: {
+      model: 'openai/gpt-5.5-mini',
+    },
+  });
+
+  const preferences = readUserPreferences();
+  assert.equal(preferences.last_used.agent, 'custom-review-agent');
+  assert.equal(preferences.last_used.harness, 'codex');
+  assert.equal(preferences.last_used.model, 'openai/gpt-5.5-mini');
+});
+
+test('user preferences preserve per-agent model/auth/settings overlays across patches', () => {
+  writeUserPreferences({
+    agent_preferences: {
+      'custom-review-agent': {
+        harness: 'codex',
+        model: 'openai/gpt-5.5',
+        authMethod: 'provider_auth',
+        modelSettings: { effort: 'medium' },
+      },
+    },
+  });
+
+  updateUserPreferences({
+    agent_preferences: {
+      'custom-review-agent': {
+        authMethod: 'amalgm',
+      },
+    },
+  });
+
+  const preferences = readUserPreferences();
+  assert.deepEqual(preferences.agent_preferences['custom-review-agent'], {
+    harness: 'codex',
+    model: 'openai/gpt-5.5',
+    authMethod: 'amalgm',
+    modelSettings: { effort: 'medium' },
+  });
+});
+
 function captureSendJson() {
   const response = {};
   return {

package/runtime/scripts/amalgm-mcp/tests/desktop-release-runner.test.js

@@ -18,6 +18,7 @@ const {
   desktopLegacyBridgePlan,
   desktopLegacyBridgeRepository,
   desktopReleaseArtifactPaths,
+  desktopReleaseMetadata,
   desktopReleaseProvider,
   desktopReleasePublishTarget,
   desktopReleaseRepository,
@@ -222,6 +223,8 @@ test('desktop release runner preserves explicit bundled desktop builds', () => {
     {
       GH_TOKEN: 'token',
       AMALGM_DESKTOP_THIN: '0',
+      NEXT_PUBLIC_SUPABASE_URL: 'https://example.supabase.co',
+      NEXT_PUBLIC_SUPABASE_ANON_KEY: 'anon-key',
     },
     { lane: 'main', delivery: 'delivery-id' },
     '0.1.124',
@@ -235,8 +238,8 @@ test('desktop release runner preserves explicit bundled desktop builds', () => {
   assert.equal(env.AMALGM_DESKTOP_RENDERER_DELIVERY, 'bundled-next');
   assert.equal(env.AMALGM_DESKTOP_RUNTIME_DELIVERY, 'bundled-with-npm-handoff');
   assert.equal(env.NEXT_IMAGE_UNOPTIMIZED, '1');
-  assert.equal(env.NEXT_PUBLIC_SUPABASE_URL, '');
-  assert.equal(env.NEXT_PUBLIC_SUPABASE_ANON_KEY, '');
+  assert.equal(env.NEXT_PUBLIC_SUPABASE_URL, 'https://example.supabase.co');
+  assert.equal(env.NEXT_PUBLIC_SUPABASE_ANON_KEY, 'anon-key');
 });
 
 test('desktop release runner supports bundled UI with npm runtime', () => {
@@ -245,6 +248,8 @@ test('desktop release runner supports bundled UI with npm runtime', () => {
       GH_TOKEN: 'token',
       AMALGM_DESKTOP_RENDERER_DELIVERY: 'bundled-next',
       AMALGM_DESKTOP_RUNTIME_DELIVERY: 'npm',
+      NEXT_PUBLIC_SUPABASE_URL: 'https://example.supabase.co',
+      NEXT_PUBLIC_SUPABASE_ANON_KEY: 'anon-key',
     },
     { lane: 'preview', delivery: 'delivery-id' },
     '0.1.124-canary.1',
@@ -257,8 +262,8 @@ test('desktop release runner supports bundled UI with npm runtime', () => {
   assert.equal(env.AMALGM_DESKTOP_RENDERER_DELIVERY, 'bundled-next');
   assert.equal(env.AMALGM_DESKTOP_RUNTIME_DELIVERY, 'npm');
   assert.equal(env.NEXT_IMAGE_UNOPTIMIZED, '1');
-  assert.equal(env.NEXT_PUBLIC_SUPABASE_URL, '');
-  assert.equal(env.NEXT_PUBLIC_SUPABASE_ANON_KEY, '');
+  assert.equal(env.NEXT_PUBLIC_SUPABASE_URL, 'https://example.supabase.co');
+  assert.equal(env.NEXT_PUBLIC_SUPABASE_ANON_KEY, 'anon-key');
 });
 
 test('desktop release runner omits blank certificate file secrets', () => {
@@ -507,6 +512,77 @@ test('desktop release runner rewrites bridge channel YAML to absolute Fly asset
   assert.equal(info.packages.arm64.path, 'https://amalgm-desktop-releases.fly.dev/main/amalgm-0.1.124000001-arm64.pkg');
 });
 
+test('desktop release runner records primary download and updater artifacts in release metadata', () => {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-desktop-release-metadata-test-'));
+  const channelPath = path.join(tempRoot, 'latest-mac.yml');
+  const artifacts = [
+    path.join(tempRoot, 'amalgm-local-ui-0.1.124000001-arm64-mac.zip'),
+    path.join(tempRoot, 'amalgm-local-ui-0.1.124000001-arm64.dmg'),
+    channelPath,
+  ];
+
+  try {
+    fs.writeFileSync(channelPath, [
+      'version: 0.1.124000001',
+      'files:',
+      '  - url: amalgm-local-ui-0.1.124000001-arm64-mac.zip',
+      '    sha512: zip-sha',
+      '    size: 123',
+      '  - url: amalgm-local-ui-0.1.124000001-arm64.dmg',
+      '    sha512: dmg-sha',
+      '    size: 456',
+      'path: amalgm-local-ui-0.1.124000001-arm64-mac.zip',
+      'sha512: zip-sha',
+      '',
+    ].join('\n'));
+
+    const metadata = desktopReleaseMetadata({
+      tag: 'v0.1.124000001',
+      version: '0.1.124000001',
+      request: {
+        lane: 'main',
+        branch: 'main',
+        repository: 'amalgm-inc/amalgm-engine',
+        delivery: 'unit-test',
+      },
+      refs: {
+        engineRef: 'main',
+        uiRef: 'main',
+      },
+      shas: {
+        engineSha: '1'.repeat(40),
+        uiSha: '2'.repeat(40),
+      },
+      sourcePackageVersion: '0.1.124',
+      publishTarget: {
+        provider: 'fly',
+        updateProvider: 'generic',
+        updateUrl: 'https://amalgm-desktop-releases.fly.dev/main/',
+        channelUrl: 'https://amalgm-desktop-releases.fly.dev/main/latest-mac.yml',
+      },
+      artifacts,
+      channelPath,
+    });
+
+    assert.deepEqual(metadata.primaryDownload, {
+      platform: 'macos',
+      kind: 'dmg',
+      artifact: 'amalgm-local-ui-0.1.124000001-arm64.dmg',
+      size: 456,
+      sha512: 'dmg-sha',
+    });
+    assert.deepEqual(metadata.updateArtifact, {
+      platform: 'macos',
+      kind: 'zip',
+      artifact: 'amalgm-local-ui-0.1.124000001-arm64-mac.zip',
+      size: 123,
+      sha512: 'zip-sha',
+    });
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+});
+
 test('desktop release runner requires all updater artifacts', () => {
   const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-desktop-release-artifacts-test-'));
   const version = '0.1.124000001-preview.1';

package/runtime/scripts/amalgm-mcp/tests/desktop-release-server.test.js

@@ -10,6 +10,7 @@ const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-desktop-release-s
 process.env.DATA_ROOT = tempRoot;
 
 const {
+  channelInfoFromMetadata,
   cleanupReleaseLane,
   createServer,
   latestArtifactName,
@@ -22,10 +23,10 @@ test.after(() => {
   fs.rmSync(tempRoot, { recursive: true, force: true });
 });
 
-function writeReleaseMetadata(lane, artifacts) {
+function writeReleaseMetadata(lane, artifacts, extra = {}) {
   const laneDir = path.join(tempRoot, lane);
   fs.mkdirSync(laneDir, { recursive: true });
-  fs.writeFileSync(path.join(laneDir, 'desktop-release.json'), `${JSON.stringify({ lane, artifacts }, null, 2)}\n`);
+  fs.writeFileSync(path.join(laneDir, 'desktop-release.json'), `${JSON.stringify({ lane, artifacts, ...extra }, null, 2)}\n`);
 }
 
 function writeLaneFile(lane, fileName, mtimeOffsetMs = 0) {
@@ -53,6 +54,10 @@ function writeReleaseFiles(lane, version, mtimeOffsetMs = 0) {
 
 test('desktop release server resolves stable bridge download targets from metadata', () => {
   const artifacts = [
+    'amalgm-local-ui-0.1.1-arm64-mac.zip',
+    'amalgm-local-ui-0.1.1-arm64-mac.zip.blockmap',
+    'amalgm-local-ui-0.1.1-arm64.dmg',
+    'amalgm-local-ui-0.1.1-arm64.dmg.blockmap',
     'amalgm-thin-0.1.1-arm64-mac.zip',
     'amalgm-thin-0.1.1-arm64-mac.zip.blockmap',
     'amalgm-thin-0.1.1-arm64.dmg',
@@ -69,13 +74,41 @@ test('desktop release server resolves stable bridge download targets from metada
   assert.deepEqual(parseDownloadPath('/main/download/zip'), { lane: 'main', kind: 'zip' });
   assert.deepEqual(parseDownloadPath('/main/latest.dmg'), { lane: 'main', kind: 'dmg' });
   assert.equal(parseDownloadPath('/main/latest-mac.yml'), null);
-  assert.equal(latestArtifactName({ artifacts }, 'dmg'), 'amalgm-thin-0.1.1-arm64.dmg');
+  assert.equal(latestArtifactName({ artifacts }, 'dmg'), 'amalgm-local-ui-0.1.1-arm64.dmg');
   assert.deepEqual(latestDownloadTarget('main', 'zip'), {
     metadata: { lane: 'main', artifacts },
-    artifactName: 'amalgm-thin-0.1.1-arm64-mac.zip',
+    artifactName: 'amalgm-local-ui-0.1.1-arm64-mac.zip',
   });
 });
 
+test('desktop release server honors explicit metadata artifact descriptors', () => {
+  const metadata = {
+    artifacts: [
+      'amalgm-local-ui-0.1.1-arm64-mac.zip',
+      'amalgm-local-ui-0.1.1-arm64.dmg',
+      'amalgm-local-ui-0.1.0-arm64-mac.zip',
+      'amalgm-local-ui-0.1.0-arm64.dmg',
+    ],
+    primaryDownload: {
+      platform: 'macos',
+      kind: 'dmg',
+      artifact: 'amalgm-local-ui-0.1.1-arm64.dmg',
+      size: 456,
+      sha512: 'dmg-sha',
+    },
+    updateArtifact: {
+      platform: 'macos',
+      kind: 'zip',
+      artifact: 'amalgm-local-ui-0.1.1-arm64-mac.zip',
+      size: 123,
+      sha512: 'zip-sha',
+    },
+  };
+
+  assert.equal(latestArtifactName(metadata, 'dmg'), 'amalgm-local-ui-0.1.1-arm64.dmg');
+  assert.equal(latestArtifactName(metadata, 'zip'), 'amalgm-local-ui-0.1.1-arm64-mac.zip');
+});
+
 test('desktop release server groups versioned release artifacts', () => {
   assert.equal(
     releaseKeyForArtifact('amalgm-0.1.139881837-arm64-mac.zip.blockmap'),
@@ -89,6 +122,14 @@ test('desktop release server groups versioned release artifacts', () => {
     releaseKeyForArtifact('amalgm-preview-thin-0.1.139882282-preview.1-arm64.dmg'),
     'amalgm-preview-thin@0.1.139882282-preview.1',
   );
+  assert.equal(
+    releaseKeyForArtifact('amalgm-local-ui-0.1.150623855-arm64.dmg'),
+    'amalgm-local-ui@0.1.150623855',
+  );
+  assert.equal(
+    releaseKeyForArtifact('amalgm-preview-local-ui-0.1.139882282-preview.1-arm64.dmg'),
+    'amalgm-preview-local-ui@0.1.139882282-preview.1',
+  );
   assert.equal(releaseKeyForArtifact('latest-mac.yml'), '');
 });
 
@@ -121,6 +162,8 @@ test('desktop release server prunes stale lane artifacts after publish', () => {
 
 test('desktop release server redirects public bridge download URLs to current assets', async () => {
   writeReleaseMetadata('preview', [
+    'amalgm-preview-local-ui-0.1.1-preview.1-arm64.zip',
+    'amalgm-preview-local-ui-0.1.1-preview.1-arm64.dmg',
     'amalgm-preview-thin-0.1.1-preview.1-arm64.zip',
     'amalgm-preview-thin-0.1.1-preview.1-arm64.dmg',
     'amalgm-preview-0.1.1-preview.1-arm64.zip',
@@ -137,7 +180,7 @@ test('desktop release server redirects public bridge download URLs to current as
     assert.equal(response.status, 302);
     assert.equal(
       response.headers.get('location'),
-      `http://127.0.0.1:${port}/preview/amalgm-preview-thin-0.1.1-preview.1-arm64.dmg`,
+      `http://127.0.0.1:${port}/preview/amalgm-preview-local-ui-0.1.1-preview.1-arm64.dmg?download=amalgm-preview-macOS.dmg`,
     );
 
     const zipResponse = await fetch(`http://127.0.0.1:${port}/preview/latest.zip`, {
@@ -147,7 +190,7 @@ test('desktop release server redirects public bridge download URLs to current as
     assert.equal(zipResponse.status, 302);
     assert.equal(
       zipResponse.headers.get('location'),
-      `http://127.0.0.1:${port}/preview/amalgm-preview-thin-0.1.1-preview.1-arm64.zip`,
+      `http://127.0.0.1:${port}/preview/amalgm-preview-local-ui-0.1.1-preview.1-arm64.zip?download=amalgm-preview-macOS.zip`,
     );
 
     const forwardedResponse = await fetch(`http://127.0.0.1:${port}/preview/download`, {
@@ -160,9 +203,54 @@ test('desktop release server redirects public bridge download URLs to current as
     assert.equal(forwardedResponse.status, 302);
     assert.equal(
       forwardedResponse.headers.get('location'),
-      'https://amalgm-desktop-releases.fly.dev/preview/amalgm-preview-thin-0.1.1-preview.1-arm64.dmg',
+      'https://amalgm-desktop-releases.fly.dev/preview/amalgm-preview-local-ui-0.1.1-preview.1-arm64.dmg?download=amalgm-preview-macOS.dmg',
     );
   } finally {
     await new Promise((resolve) => server.close(resolve));
   }
 });
+
+test('desktop release server synthesizes updater channel YAML from current metadata and files', async () => {
+  const zipName = 'amalgm-local-ui-0.1.200000001-arm64-mac.zip';
+  const dmgName = 'amalgm-local-ui-0.1.200000001-arm64.dmg';
+  writeLaneFile('main', zipName, -5_000);
+  writeLaneFile('main', dmgName, -5_000);
+  fs.writeFileSync(path.join(tempRoot, 'main', 'latest-mac.yml'), [
+    'version: 0.1.100000000',
+    'path: stale.zip',
+    'sha512: stale-sha',
+    '',
+  ].join('\n'));
+  writeReleaseMetadata('main', [zipName, dmgName, 'latest-mac.yml'], {
+    version: '0.1.200000001',
+    publishedAt: '2026-07-05T20:00:00.000Z',
+  });
+
+  const info = channelInfoFromMetadata('main', {
+    lane: 'main',
+    version: '0.1.200000001',
+    artifacts: [zipName, dmgName, 'latest-mac.yml'],
+    publishedAt: '2026-07-05T20:00:00.000Z',
+  });
+  assert.equal(info.version, '0.1.200000001');
+  assert.equal(info.path, zipName);
+  assert.equal(info.files[0].url, zipName);
+  assert.equal(info.files[1].url, dmgName);
+
+  const server = createServer();
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const { port } = server.address();
+
+  try {
+    const response = await fetch(`http://127.0.0.1:${port}/main/latest-mac.yml`);
+    assert.equal(response.status, 200);
+    const parsed = require('js-yaml').load(await response.text());
+    assert.equal(parsed.version, '0.1.200000001');
+    assert.equal(parsed.path, zipName);
+    assert.equal(parsed.files[0].url, zipName);
+    assert.equal(parsed.files[1].url, dmgName);
+    assert.equal(parsed.releaseDate, '2026-07-05T20:00:00.000Z');
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+  }
+});