amalgm 0.1.136 → 0.1.137

package/package.json

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

package/runtime/scripts/amalgm-mcp/agent-bundles/bundles.js

@@ -216,6 +216,17 @@ function cleanEntryId(value) {
   return typeof value === 'string' ? value.trim() : '';
 }
 
+/**
+ * Tools shared as top-level primitives (not just dependencies of agents or
+ * automations). The bundle's explicit heads are the single source of truth.
+ */
+function standaloneToolIds(bundle) {
+  const heads = Array.isArray(bundle?.heads) ? bundle.heads : [];
+  return uniqueStrings(heads
+    .filter((head) => isObject(head) && cleanEntryId(head.type) === 'tool')
+    .map((head) => cleanEntryId(head.id)));
+}
+
 /**
  * App elements carry the portable record and a file manifest; file contents
  * stay in bundle.apps[] so the graph remains cheap to render.
@@ -353,7 +364,10 @@ function buildFlatAgentBundleGraph(bundle) {
     }
   }
 
-  for (const toolId of includedToolIds) {
+  // Every tool in bundle.tools gets an element — standalone tool heads are
+  // not referenced by any agent or automation edge but must still resolve.
+  const toolElementIds = new Set([...includedToolIds, ...toolMap.keys()]);
+  for (const toolId of toolElementIds) {
     const tool = toolMap.get(toolId);
     pushGraphElement(elements, {
       id: graphElementId('tool', toolId),
@@ -370,7 +384,7 @@ function buildFlatAgentBundleGraph(bundle) {
   }
 
   for (const action of Array.isArray(bundle.toolActions) ? bundle.toolActions : []) {
-    if (!includedToolIds.has(action.toolId)) continue;
+    if (!toolElementIds.has(action.toolId)) continue;
     includedActionIds.add(action.id);
     pushGraphElement(elements, {
       id: graphElementId('tool_action', action.id),
@@ -529,7 +543,7 @@ function collectAgentGraph(rootAgentId) {
   return ordered;
 }
 
-function bundleTitleAndDescription(agents, automations, apps) {
+function bundleTitleAndDescription(agents, automations, apps, sharedTools) {
   const firstAgent = agents[0]?.agent;
   if (firstAgent) {
     return { title: firstAgent.name || 'Shared agent', description: firstAgent.description || '' };
@@ -542,6 +556,10 @@ function bundleTitleAndDescription(agents, automations, apps) {
   if (firstApp) {
     return { title: firstApp.name || 'Shared app', description: firstApp.description || '' };
   }
+  const firstTool = sharedTools?.[0];
+  if (firstTool) {
+    return { title: firstTool.name || 'Shared tool', description: firstTool.description || '' };
+  }
   return { title: 'Shared bundle', description: '' };
 }
 
@@ -566,8 +584,9 @@ function createBundle(input = {}, options = {}) {
   const agentIds = uniqueStrings(input.agentIds);
   const automationIds = uniqueStrings(input.automationIds);
   const appIds = uniqueStrings(input.appIds);
-  if (agentIds.length === 0 && automationIds.length === 0 && appIds.length === 0) {
-    throw new Error('At least one agent, automation, or app is required');
+  const toolIds = uniqueStrings(input.toolIds);
+  if (agentIds.length === 0 && automationIds.length === 0 && appIds.length === 0 && toolIds.length === 0) {
+    throw new Error('At least one agent, automation, app, or tool is required');
   }
 
   const requires = {
@@ -614,7 +633,15 @@ function createBundle(input = {}, options = {}) {
     skippedAppFiles += exported.skipped.length;
   }
 
-  const { tools, toolActions } = collectToolRecords(loadoutToolIds, requires);
+  const { tools, toolActions } = collectToolRecords([...loadoutToolIds, ...toolIds], requires);
+  // Standalone tool heads must resolve to a real catalog tool — a dependency
+  // tool that is missing degrades to a placeholder, but a head cannot.
+  const sharedToolIds = toolIds.filter((toolId) => tools.some((tool) => tool.id === toolId));
+  const missingSharedToolIds = toolIds.filter((toolId) => !sharedToolIds.includes(toolId));
+  if (missingSharedToolIds.length > 0) {
+    throw new Error(`Tool not found: ${missingSharedToolIds.join(', ')}`);
+  }
+  const sharedTools = sharedToolIds.map((toolId) => tools.find((tool) => tool.id === toolId));
   const skills = collectSkillRecords(agents);
   const hooks = countHooks(agents);
   const warnings = bundleWarnings({
@@ -624,15 +651,18 @@ function createBundle(input = {}, options = {}) {
     apps: apps.length,
     skippedAppFiles,
   });
-  const { title, description } = bundleTitleAndDescription(agents, automations, apps);
+  const { title, description } = bundleTitleAndDescription(agents, automations, apps, sharedTools);
   const heads = [
     ...agentIds.map((id) => ({ type: 'agent', id })),
     ...automationIds.map((id) => ({ type: 'automation', id })),
     ...appIds.map((id) => ({ type: 'app', id })),
+    ...sharedToolIds.map((id) => ({ type: 'tool', id })),
   ];
 
   const bundle = withBundleGraph({
-    kind: automations.length > 0 || apps.length > 0 ? BUNDLE_KIND : LEGACY_AGENT_BUNDLE_KIND,
+    kind: automations.length > 0 || apps.length > 0 || sharedToolIds.length > 0
+      ? BUNDLE_KIND
+      : LEGACY_AGENT_BUNDLE_KIND,
     schemaVersion: BUNDLE_SCHEMA_VERSION,
     bundleId: options.bundleId || bundleId(),
     createdAt: nowIso(),
@@ -778,8 +808,9 @@ function validateBundle(bundle) {
   const agents = Array.isArray(bundle.agents) ? bundle.agents : [];
   const automations = Array.isArray(bundle.automations) ? bundle.automations : [];
   const apps = Array.isArray(bundle.apps) ? bundle.apps : [];
-  if (agents.length === 0 && automations.length === 0 && apps.length === 0) {
-    throw new Error('bundle must include at least one agent, automation, or app');
+  const toolHeads = standaloneToolIds(bundle);
+  if (agents.length === 0 && automations.length === 0 && apps.length === 0 && toolHeads.length === 0) {
+    throw new Error('bundle must include at least one agent, automation, app, or tool');
   }
   if (agents.length > 0) assertClosedAgentBundleGraph(bundle);
   return withBundleGraph(bundle);

package/runtime/scripts/amalgm-mcp/agent-bundles/rest.js

@@ -22,12 +22,13 @@ async function handlePreview(body, sendJson) {
   const agentIds = idList(body?.agent_id, body?.agent_ids);
   const automationIds = idList(body?.automation_id, body?.automation_ids);
   const appIds = idList(body?.app_id, body?.app_ids);
-  if (agentIds.length === 0 && automationIds.length === 0 && appIds.length === 0) {
-    return sendJson(400, { error: 'At least one of agent_ids, automation_ids, or app_ids is required' });
+  const toolIds = idList(body?.tool_id, body?.tool_ids);
+  if (agentIds.length === 0 && automationIds.length === 0 && appIds.length === 0 && toolIds.length === 0) {
+    return sendJson(400, { error: 'At least one of agent_ids, automation_ids, app_ids, or tool_ids is required' });
   }
 
   try {
-    const result = createBundle({ agentIds, automationIds, appIds });
+    const result = createBundle({ agentIds, automationIds, appIds, toolIds });
     return sendJson(200, { ok: true, ...result });
   } catch (error) {
     return sendJson(400, { error: error.message || 'Failed to create bundle' });

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

@@ -1,5 +1,6 @@
 'use strict';
 
+const crypto = require('crypto');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
@@ -19,11 +20,105 @@ const DEFAULT_DESKTOP_UPDATE_BASE_URL = 'https://amalgm-desktop-releases.fly.dev
 const DEFAULT_DESKTOP_RELEASE_FLY_APP = 'amalgm-desktop-releases';
 const DEFAULT_DESKTOP_RELEASE_FLY_ROOT = '/data';
 const DEFAULT_DESKTOP_RELEASE_UPLOAD_CHUNK_BYTES = 2 * 1024 * 1024;
+const DEFAULT_DESKTOP_NOTARY_SUBMISSION_DISCOVERY_TIMEOUT_MS = 2 * 60 * 1000;
+const DEFAULT_DESKTOP_NOTARY_DECISION_TIMEOUT_MS = 2 * 60 * 60 * 1000;
+const DEFAULT_DESKTOP_NOTARY_POLL_INTERVAL_MS = 15 * 1000;
 
 function cleanString(value) {
   return typeof value === 'string' ? value.trim() : '';
 }
 
+function booleanEnv(value, defaultValue = false) {
+  const raw = cleanString(value).toLowerCase();
+  if (!raw) return defaultValue;
+  if (['1', 'true', 'yes', 'on'].includes(raw)) return true;
+  if (['0', 'false', 'no', 'off'].includes(raw)) return false;
+  throw new Error(`Invalid boolean environment value: ${value}`);
+}
+
+function manualDesktopNotarizationEnabled(env = process.env) {
+  return booleanEnv(env.AMALGM_DESKTOP_RELEASE_MANUAL_NOTARIZE, true);
+}
+
+function codesignIdentityForCli(env = process.env) {
+  const raw = cleanString(
+    env.AMALGM_DESKTOP_CODESIGN_IDENTITY
+    || env.CSC_NAME
+    || DEFAULT_CSC_NAME,
+  ).replace(/^Developer ID Application:\s*/i, '');
+  if (!raw) throw new Error('Missing macOS code signing identity for manual DMG signing.');
+  return `Developer ID Application: ${raw}`;
+}
+
+function appBuilderBinaryRelativePath(platform = process.platform, arch = process.arch) {
+  if (platform === 'darwin') {
+    return path.join('mac', arch === 'arm64' ? 'app-builder_arm64' : 'app-builder_amd64');
+  }
+  if (platform === 'linux') {
+    return path.join('linux', arch, 'app-builder');
+  }
+  if (platform === 'win32') {
+    if (arch === 'arm64') return path.join('win', 'arm64', 'app-builder.exe');
+    if (arch === 'ia32') return path.join('win', 'ia32', 'app-builder.exe');
+    return path.join('win', 'x64', 'app-builder.exe');
+  }
+  throw new Error(`Unsupported platform for app-builder binary lookup: ${platform}`);
+}
+
+function appBuilderBinaryPath(engineDir, env = process.env, platform = process.platform, arch = process.arch) {
+  const override = cleanString(env.AMALGM_DESKTOP_APP_BUILDER_BIN);
+  if (override) return override;
+  const binaryPath = path.join(
+    engineDir,
+    'node_modules',
+    'app-builder-bin',
+    appBuilderBinaryRelativePath(platform, arch),
+  );
+  if (!fs.existsSync(binaryPath)) {
+    throw new Error(`Missing app-builder binary for desktop blockmap generation: ${binaryPath}`);
+  }
+  return binaryPath;
+}
+
+function notarytoolCredentialArgs(env = process.env) {
+  const apiKey = cleanString(env.APPLE_API_KEY);
+  const apiKeyId = cleanString(env.APPLE_API_KEY_ID);
+  const apiIssuer = cleanString(env.APPLE_API_ISSUER);
+  if (apiKey || apiKeyId || apiIssuer) {
+    if (!apiKey || !apiKeyId || !apiIssuer) {
+      throw new Error('Incomplete Apple API key notarization credentials. Expected APPLE_API_KEY, APPLE_API_KEY_ID, and APPLE_API_ISSUER.');
+    }
+    if (!fs.existsSync(apiKey)) throw new Error(`APPLE_API_KEY file does not exist: ${apiKey}`);
+    return {
+      args: ['--key', apiKey, '--key-id', apiKeyId, '--issuer', apiIssuer],
+      credentialType: 'api-key',
+    };
+  }
+
+  const appleId = cleanString(env.APPLE_ID);
+  const appPassword = cleanString(env.APPLE_APP_SPECIFIC_PASSWORD);
+  const teamId = cleanString(env.APPLE_TEAM_ID);
+  if (appleId || appPassword || teamId) {
+    if (!appleId || !appPassword || !teamId) {
+      throw new Error('Incomplete Apple ID notarization credentials. Expected APPLE_ID, APPLE_APP_SPECIFIC_PASSWORD, and APPLE_TEAM_ID.');
+    }
+    return {
+      args: ['--apple-id', appleId, '--password', appPassword, '--team-id', teamId],
+      credentialType: 'apple-id',
+    };
+  }
+
+  const keychainProfile = cleanString(env.APPLE_KEYCHAIN_PROFILE);
+  if (keychainProfile) {
+    return {
+      args: ['--keychain-profile', keychainProfile],
+      credentialType: 'keychain-profile',
+    };
+  }
+
+  throw new Error('Missing Apple notarization credentials for manual desktop release notarization.');
+}
+
 function parseRepoFullName(value) {
   const raw = cleanString(value);
   const match = /^([^/\s]+)\/([^/\s]+)$/.exec(raw);
@@ -348,7 +443,7 @@ function appendReleaseLog(filePath, text) {
   fs.appendFileSync(logFile, text);
 }
 
-function run(command, args, options = {}) {
+function runResult(command, args, options = {}) {
   const printable = [command, ...args].join(' ');
   const logFile = releaseLogFile(options);
   appendReleaseLog(logFile, [
@@ -372,6 +467,12 @@ function run(command, args, options = {}) {
   if (result.stdout) process.stdout.write(result.stdout);
   if (result.stderr) process.stderr.write(result.stderr);
   if (result.error) throw result.error;
+  return result;
+}
+
+function run(command, args, options = {}) {
+  const printable = [command, ...args].join(' ');
+  const result = runResult(command, args, options);
   if (result.status !== 0) {
     throw new Error(`${printable} failed with exit code ${result.status ?? result.signal ?? 'unknown'}`);
   }
@@ -582,7 +683,7 @@ function envForBuild(
     ...baseEnv,
     DESKTOP_RELEASE_LANE: request.lane,
     DESKTOP_RELEASE_CHANNEL: request.lane === 'preview' ? 'preview' : 'latest',
-    AMALGM_DESKTOP_THIN: cleanString(baseEnv.AMALGM_DESKTOP_THIN) || '1',
+    AMALGM_DESKTOP_THIN: desktopThinRuntimeBuildEnabled(baseEnv) ? '1' : '0',
     AMALGM_RUNTIME_LABEL: request.lane === 'preview' ? 'preview' : 'main',
     AMALGM_BRANCH: request.lane,
     ELECTRON_VERSION: version,
@@ -597,6 +698,9 @@ function envForBuild(
     AMALGM_DESKTOP_UPDATE_PROVIDER: publishTarget.updateProvider || normalizeUpdateProviderForRelease(publishTarget.provider),
     CSC_NAME: baseEnv.CSC_NAME || DEFAULT_CSC_NAME,
   };
+  if (manualDesktopNotarizationEnabled(baseEnv)) {
+    env.AMALGM_DESKTOP_NOTARIZE = 'off';
+  }
   if (token) {
     env.GH_TOKEN = token;
     env.GITHUB_TOKEN = token;
@@ -625,6 +729,14 @@ function envForBuild(
   return env;
 }
 
+function desktopThinRuntimeBuildEnabled(env = process.env) {
+  const raw = cleanString(env.AMALGM_DESKTOP_THIN || env.DESKTOP_THIN_BUILD).toLowerCase();
+  if (!raw) return true;
+  if (['1', 'true', 'yes', 'on'].includes(raw)) return true;
+  if (['0', 'false', 'no', 'off'].includes(raw)) return false;
+  throw new Error(`Unsupported AMALGM_DESKTOP_THIN value: ${raw}`);
+}
+
 function appOriginForLane(lane, env = process.env) {
   if (lane === 'preview') {
     return cleanString(env.AMALGM_DESKTOP_PREVIEW_APP_ORIGIN)
@@ -700,6 +812,295 @@ function desktopReleaseArtifactPaths(buildDir, lane, version) {
   ];
 }
 
+function desktopAppBundlePath(engineDir, lane) {
+  const appName = lane === 'preview' ? 'amalgm-preview.app' : 'amalgm.app';
+  return path.join(engineDir, 'build', 'mac-arm64', appName);
+}
+
+function releaseArtifactPath(artifactPaths, suffix) {
+  const match = artifactPaths.find((filePath) => (
+    filePath.endsWith(suffix)
+    && !filePath.endsWith(`${suffix}.blockmap`)
+  ));
+  if (!match) throw new Error(`Missing desktop release artifact with suffix ${suffix}`);
+  return match;
+}
+
+function parseJsonOutput(raw, label) {
+  try {
+    return JSON.parse(String(raw || ''));
+  } catch (error) {
+    throw new Error(`Failed to parse ${label} JSON: ${error.message}`);
+  }
+}
+
+function sha512Base64(filePath) {
+  const hash = crypto.createHash('sha512');
+  hash.update(fs.readFileSync(filePath));
+  return hash.digest('base64');
+}
+
+function updateChannelArtifactDigest(channelPath, filePath) {
+  if (!channelPath) return;
+  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}`);
+  }
+
+  const assetName = path.basename(filePath);
+  const size = fs.statSync(filePath).size;
+  const sha512 = sha512Base64(filePath);
+  if (Array.isArray(info.files)) {
+    for (const file of info.files) {
+      if (!file || typeof file !== 'object' || Array.isArray(file)) continue;
+      if (cleanString(file.url) !== assetName) continue;
+      file.size = size;
+      file.sha512 = sha512;
+    }
+  }
+  if (cleanString(info.path) === assetName) {
+    info.sha512 = sha512;
+  }
+
+  fs.writeFileSync(channelPath, yaml.dump(info, {
+    lineWidth: -1,
+    noRefs: true,
+    sortKeys: false,
+  }));
+}
+
+function regenerateArtifactBlockmap(engineDir, artifactPath, env = process.env) {
+  const blockmapPath = `${artifactPath}.blockmap`;
+  run(appBuilderBinaryPath(engineDir, env), [
+    'blockmap',
+    '--input',
+    artifactPath,
+    '--output',
+    blockmapPath,
+  ], {
+    cwd: engineDir,
+    env,
+    maxBuffer: 20 * 1024 * 1024,
+  });
+  return blockmapPath;
+}
+
+function recreateZipFromAppBundle(engineDir, appPath, zipPath, env = process.env) {
+  const tempZipPath = `${zipPath}.tmp-${process.pid}`;
+  fs.rmSync(tempZipPath, { force: true });
+  try {
+    run('ditto', [
+      '-c',
+      '-k',
+      '--sequesterRsrc',
+      '--keepParent',
+      appPath,
+      tempZipPath,
+    ], {
+      cwd: engineDir,
+      env,
+      maxBuffer: 20 * 1024 * 1024,
+    });
+    fs.renameSync(tempZipPath, zipPath);
+    return zipPath;
+  } catch (error) {
+    fs.rmSync(tempZipPath, { force: true });
+    throw error;
+  }
+}
+
+function parseNotarySubmissionId(payload) {
+  return cleanString(
+    payload?.id
+    || payload?.submissionId
+    || payload?.notarizationUpload?.id,
+  );
+}
+
+function parseNotaryStatus(payload) {
+  return cleanString(
+    payload?.status
+    || payload?.Status
+    || payload?.notarizationUpload?.status,
+  );
+}
+
+function notaryPollIntervalMs(env = process.env) {
+  return Math.max(1_000, Number(env.AMALGM_DESKTOP_NOTARY_POLL_INTERVAL_MS) || DEFAULT_DESKTOP_NOTARY_POLL_INTERVAL_MS);
+}
+
+function notarySubmissionDiscoveryTimeoutMs(env = process.env) {
+  return Math.max(5_000, Number(env.AMALGM_DESKTOP_NOTARY_SUBMISSION_DISCOVERY_TIMEOUT_MS) || DEFAULT_DESKTOP_NOTARY_SUBMISSION_DISCOVERY_TIMEOUT_MS);
+}
+
+function notaryDecisionTimeoutMs(env = process.env) {
+  return Math.max(30_000, Number(env.AMALGM_DESKTOP_NOTARY_DECISION_TIMEOUT_MS) || DEFAULT_DESKTOP_NOTARY_DECISION_TIMEOUT_MS);
+}
+
+function notaryHistoryEntries(cwd, env, authArgs) {
+  const stdout = run('xcrun', [
+    'notarytool',
+    'history',
+    ...authArgs,
+    '--output-format',
+    'json',
+  ], {
+    cwd,
+    env,
+    maxBuffer: 10 * 1024 * 1024,
+  });
+  const parsed = parseJsonOutput(stdout, 'notarytool history');
+  if (Array.isArray(parsed?.history)) return parsed.history;
+  if (Array.isArray(parsed?.submissions)) return parsed.submissions;
+  if (Array.isArray(parsed)) return parsed;
+  return [];
+}
+
+function waitForNotarySubmission(artifactName, startedAtMs, cwd, env, authArgs) {
+  const deadline = Date.now() + notarySubmissionDiscoveryTimeoutMs(env);
+  const threshold = startedAtMs - 60_000;
+  while (true) {
+    const entries = notaryHistoryEntries(cwd, env, authArgs)
+      .filter((entry) => cleanString(entry?.name) === artifactName)
+      .filter((entry) => {
+        const createdAt = Date.parse(cleanString(entry?.createdDate));
+        return !Number.isNaN(createdAt) && createdAt >= threshold;
+      })
+      .sort((left, right) => Date.parse(cleanString(right?.createdDate)) - Date.parse(cleanString(left?.createdDate)));
+    if (entries.length > 0) return entries[0];
+    if (Date.now() >= deadline) {
+      throw new Error(`Timed out waiting for notary submission to appear for ${artifactName}.`);
+    }
+    sleepSync(notaryPollIntervalMs(env));
+  }
+}
+
+function notaryInfo(submissionId, cwd, env, authArgs) {
+  const stdout = run('xcrun', [
+    'notarytool',
+    'info',
+    submissionId,
+    ...authArgs,
+    '--output-format',
+    'json',
+  ], {
+    cwd,
+    env,
+    maxBuffer: 10 * 1024 * 1024,
+  });
+  return parseJsonOutput(stdout, 'notarytool info');
+}
+
+function waitForNotaryDecision(submissionId, artifactName, cwd, env, authArgs) {
+  const deadline = Date.now() + notaryDecisionTimeoutMs(env);
+  let lastStatus = '';
+  while (true) {
+    const info = notaryInfo(submissionId, cwd, env, authArgs);
+    const status = parseNotaryStatus(info);
+    if (status && status !== 'In Progress') {
+      if (status !== 'Accepted') {
+        throw new Error(`Notary submission ${submissionId} for ${artifactName} finished with status ${status}.`);
+      }
+      return info;
+    }
+    lastStatus = status || lastStatus || 'In Progress';
+    if (Date.now() >= deadline) {
+      throw new Error(`Timed out waiting for notary submission ${submissionId} for ${artifactName}; last status ${lastStatus}.`);
+    }
+    sleepSync(notaryPollIntervalMs(env));
+  }
+}
+
+function submitArtifactForNotarization(filePath, cwd, env) {
+  const { args: authArgs, credentialType } = notarytoolCredentialArgs(env);
+  const startedAtMs = Date.now();
+  const artifactName = path.basename(filePath);
+  const result = runResult('xcrun', [
+    'notarytool',
+    'submit',
+    filePath,
+    ...authArgs,
+    '--no-progress',
+    '--output-format',
+    'json',
+  ], {
+    cwd,
+    env,
+    maxBuffer: 10 * 1024 * 1024,
+  });
+
+  let submissionId = '';
+  if (cleanString(result.stdout)) {
+    try {
+      submissionId = parseNotarySubmissionId(parseJsonOutput(result.stdout, 'notarytool submit'));
+    } catch {
+      submissionId = '';
+    }
+  }
+  if (!submissionId) {
+    submissionId = parseNotarySubmissionId(waitForNotarySubmission(artifactName, startedAtMs, cwd, env, authArgs));
+  }
+  if (!submissionId) {
+    throw new Error(`Failed to resolve notary submission id for ${artifactName}.`);
+  }
+  if (result.status !== 0) {
+    console.warn(`notarytool submit exited with code ${result.status} for ${artifactName}; continuing with submission ${submissionId}.`);
+  }
+
+  const info = waitForNotaryDecision(submissionId, artifactName, cwd, env, authArgs);
+  return {
+    id: submissionId,
+    status: parseNotaryStatus(info),
+    credentialType,
+    info,
+  };
+}
+
+function manualNotarizeDesktopArtifacts({ engineDir, lane, env, artifactPaths, channelPath }) {
+  const appPath = desktopAppBundlePath(engineDir, lane);
+  const zipPath = releaseArtifactPath(artifactPaths, '.zip');
+  const dmgPath = releaseArtifactPath(artifactPaths, '.dmg');
+
+  run('codesign', ['--verify', '--deep', '--strict', appPath], { cwd: engineDir, env });
+  run('hdiutil', ['verify', dmgPath], { cwd: engineDir, env, maxBuffer: 10 * 1024 * 1024 });
+
+  run('codesign', [
+    '--force',
+    '--sign',
+    codesignIdentityForCli(env),
+    '--timestamp',
+    dmgPath,
+  ], {
+    cwd: engineDir,
+    env,
+  });
+  run('hdiutil', ['verify', dmgPath], { cwd: engineDir, env, maxBuffer: 10 * 1024 * 1024 });
+  const dmgNotarization = submitArtifactForNotarization(dmgPath, engineDir, env);
+  run('xcrun', ['stapler', 'staple', appPath], { cwd: engineDir, env });
+  run('xcrun', ['stapler', 'validate', appPath], { cwd: engineDir, env });
+  run('spctl', ['--assess', '--type', 'execute', '--verbose=4', appPath], { cwd: engineDir, env });
+  run('xcrun', ['stapler', 'staple', dmgPath], { cwd: engineDir, env });
+  run('xcrun', ['stapler', 'validate', dmgPath], { cwd: engineDir, env });
+  run('spctl', ['-a', '-vvv', '-t', 'install', dmgPath], { cwd: engineDir, env });
+  const dmgBlockmapPath = regenerateArtifactBlockmap(engineDir, dmgPath, env);
+  recreateZipFromAppBundle(engineDir, appPath, zipPath, env);
+  const zipBlockmapPath = regenerateArtifactBlockmap(engineDir, zipPath, env);
+
+  updateChannelArtifactDigest(channelPath, zipPath);
+  updateChannelArtifactDigest(channelPath, dmgPath);
+
+  return {
+    enabled: true,
+    appPath,
+    zipPath,
+    dmgPath,
+    dmgBlockmapPath,
+    zipBlockmapPath,
+    dmgSubmissionId: dmgNotarization.id,
+  };
+}
+
 function githubReleaseId(tag, cwd, env, releaseRepository = desktopReleaseRepository(env)) {
   try {
     const publishedReleaseId = cleanString(run('gh', [
@@ -1261,6 +1662,7 @@ function publishDesktopRelease(request, options = {}) {
       flyApp: publishTarget.flyApp || '',
       flyRemoteDir: publishTarget.remoteDir || '',
       releaseRepository: releaseRepository.fullName,
+      manualNotarization: manualDesktopNotarizationEnabled(releaseEnv),
       legacyBridge: desktopLegacyBridgePlan(releaseEnv, publishTarget),
     };
   }
@@ -1299,10 +1701,19 @@ function publishDesktopRelease(request, options = {}) {
   run('git', ['push', 'origin', `refs/tags/v${version}`, '--force'], { cwd: engineDir });
   run('npm', ['version', '--no-git-tag-version', '--allow-same-version', version], { cwd: engineDir, env: releaseEnv });
   run('npm', ['run', 'compile'], { cwd: engineDir, env: releaseEnv });
-  run('npm', ['run', 'npm:sync'], { cwd: engineDir, env: releaseEnv });
-  copyUiIntoEngine(uiDir, engineDir);
-  const appOrigin = writeBundledWebEnv(engineDir, request.lane, releaseEnv);
-  run('npm', ['run', 'build:next'], { cwd: engineDir, env: releaseEnv });
+  const thinRuntimeBuild = desktopThinRuntimeBuildEnabled(releaseEnv);
+  let appOrigin = appOriginForLane(request.lane, releaseEnv);
+  if (thinRuntimeBuild) {
+    if (!cleanString(releaseEnv.NEXT_PUBLIC_SUPABASE_URL)) {
+      throw new Error('Missing NEXT_PUBLIC_SUPABASE_URL for thin desktop auth metadata.');
+    }
+    console.log('Building thin hosted-UI desktop shell; skipping bundled runtime and Next.js renderer payload.');
+  } else {
+    run('npm', ['run', 'npm:sync'], { cwd: engineDir, env: releaseEnv });
+    copyUiIntoEngine(uiDir, engineDir);
+    appOrigin = writeBundledWebEnv(engineDir, request.lane, releaseEnv);
+    run('npm', ['run', 'build:next'], { cwd: engineDir, env: releaseEnv });
+  }
   if (request.lane === 'preview') run('npm', ['run', 'assets:preview-icon'], { cwd: engineDir, env: releaseEnv });
 
   const buildEnv = envForBuild(releaseEnv, request, sourcePackageVersion, version, refs, shas, appOrigin, releaseRepository, publishTarget);
@@ -1319,6 +1730,15 @@ function publishDesktopRelease(request, options = {}) {
   const tag = `v${version}`;
   const artifacts = desktopReleaseArtifactPaths(path.join(engineDir, 'build'), request.lane, version);
   const channelPath = artifacts.find((filePath) => filePath.endsWith('-mac.yml'));
+  const manualNotarization = manualDesktopNotarizationEnabled(releaseEnv)
+    ? manualNotarizeDesktopArtifacts({
+      engineDir,
+      lane: request.lane,
+      env: buildEnv,
+      artifactPaths: artifacts,
+      channelPath,
+    })
+    : { enabled: false };
   let releaseUrl = '';
   let legacyBridge = null;
   if (publishTarget.provider === 'github') {
@@ -1358,6 +1778,7 @@ function publishDesktopRelease(request, options = {}) {
     flyApp: publishTarget.flyApp || '',
     flyRemoteDir: publishTarget.remoteDir || '',
     releaseRepository: releaseRepository.fullName,
+    manualNotarization,
     legacyBridge,
     artifacts: artifacts.map((filePath) => path.basename(filePath)),
     repository: request.repository,
@@ -1387,7 +1808,10 @@ if (require.main === module) {
 module.exports = {
   absoluteAssetUrl,
   applyDesktopReleaseEnv,
+  appBuilderBinaryPath,
+  appBuilderBinaryRelativePath,
   bridgeChannelInfoForBase,
+  codesignIdentityForCli,
   buildNumberFromNow,
   desktopLegacyBridgeEnabled,
   desktopLegacyBridgePlan,
@@ -1400,10 +1824,13 @@ module.exports = {
   desktopVersion,
   desktopReleaseArtifactPaths,
   envForBuild,
+  manualDesktopNotarizationEnabled,
+  notarytoolCredentialArgs,
   parseEnvFile,
   parseUploadOffsetMismatch,
   publishLegacyGithubBridgeRelease,
   publishDesktopRelease,
+  recreateZipFromAppBundle,
   recoverableUploadOffset,
   requestFromEnv,
   shouldHandleRequest,

package/runtime/scripts/amalgm-mcp/tests/bundle-entries.test.js

@@ -239,7 +239,7 @@ test('mixed bundle carries automations and apps with heads and installs everythi
 test('legacy agent-only bundles still validate and empty bundles are rejected', () => {
   assert.throws(
     () => validateBundle({ kind: 'amalgm.bundle', schemaVersion: 1 }),
-    /at least one agent, automation, or app/,
+    /at least one agent, automation, app, or tool/,
   );
   assert.throws(
     () => validateBundle({ kind: 'something.else', schemaVersion: 1 }),
@@ -247,6 +247,110 @@ test('legacy agent-only bundles still validate and empty bundles are rejected',
   );
 });
 
+test('standalone tool bundle carries the tool as a head and installs it', async () => {
+  const { defaultToolboxService } = require('../toolbox/service');
+  defaultToolboxService.registerTool({
+    id: 'acme.standalone',
+    name: 'Acme Standalone',
+    description: 'A standalone shareable tool',
+    type: 'cli',
+    origin: 'user',
+    source: { command: 'acme-standalone', inputMode: 'json-stdin', outputMode: 'json' },
+    actions: [{
+      id: 'acme.standalone.run',
+      name: 'run',
+      description: 'Run it.',
+      inputSchema: { type: 'object' },
+    }],
+  });
+
+  const { bundle, preview } = createBundle({ toolIds: ['acme.standalone'] });
+
+  assert.equal(bundle.kind, 'amalgm.bundle');
+  assert.equal(bundle.title, 'Acme Standalone');
+  assert.deepEqual(bundle.heads, [{ type: 'tool', id: 'acme.standalone' }]);
+  assert.deepEqual(bundle.headIds, ['tool:acme.standalone']);
+  assert.equal(bundle.tools.length, 1);
+  assert.equal(bundle.toolActions.length, 1);
+  const toolElement = bundle.elements.find((element) => element.id === 'tool:acme.standalone');
+  assert.equal(toolElement.label, 'Acme Standalone');
+  const actionElement = bundle.elements.find((element) => element.type === 'tool_action');
+  assert.equal(actionElement.data.id, 'acme.standalone.run');
+  assert.equal(preview.tools.length, 1);
+
+  const revived = validateBundle(JSON.parse(JSON.stringify(bundle)));
+  assert.deepEqual(revived.headIds, ['tool:acme.standalone']);
+
+  defaultToolboxService.deleteTool('acme.standalone');
+  const result = await installBundle(JSON.parse(JSON.stringify(bundle)));
+  assert.equal(result.ok, true);
+  assert.equal(result.installedTools.length, 1);
+  assert.equal(result.installedTools[0].id, 'acme.standalone');
+  const catalog = defaultToolboxService.readCatalog();
+  assert.equal(catalog.tools['acme.standalone'].name, 'Acme Standalone');
+  assert.equal(Boolean(catalog.toolActions['acme.standalone.run']), true);
+});
+
+test('unknown standalone tool ids are rejected at export', () => {
+  assert.throws(
+    () => createBundle({ toolIds: ['does.not.exist'] }),
+    /Tool not found: does\.not\.exist/,
+  );
+});
+
+test('tools shared by multiple agents and standalone stay canonical (one record per id)', () => {
+  const { createAgent } = require('../agents/store');
+  const { upsertAgentConfig } = require('../agent-config/store');
+  const { defaultToolboxService } = require('../toolbox/service');
+
+  defaultToolboxService.registerTool({
+    id: 'acme.shared',
+    name: 'Acme Shared',
+    type: 'cli',
+    origin: 'user',
+    source: { command: 'acme-shared', inputMode: 'json-stdin', outputMode: 'json' },
+    actions: [{ id: 'acme.shared.run', name: 'run', inputSchema: { type: 'object' } }],
+  });
+
+  const left = createAgent({
+    id: 'dedupe-left',
+    name: 'Dedupe Left',
+    baseHarnessId: 'codex',
+    loadout: { toolIds: ['acme.shared'] },
+    authMethod: 'amalgm',
+  });
+  upsertAgentConfig(left.id, { instructions: 'left', loadout: { toolIds: ['acme.shared'] } });
+  const right = createAgent({
+    id: 'dedupe-right',
+    name: 'Dedupe Right',
+    baseHarnessId: 'codex',
+    loadout: { toolIds: ['acme.shared'] },
+    authMethod: 'amalgm',
+  });
+  upsertAgentConfig(right.id, { instructions: 'right', loadout: { toolIds: ['acme.shared'] } });
+
+  const { bundle } = createBundle({
+    agentIds: [left.id, right.id],
+    toolIds: ['acme.shared'],
+  });
+
+  // One canonical tool record and element; both agents point edges at it.
+  assert.equal(bundle.tools.filter((tool) => tool.id === 'acme.shared').length, 1);
+  assert.equal(
+    bundle.elements.filter((element) => element.id === 'tool:acme.shared').length,
+    1,
+  );
+  const usesToolEdges = bundle.edges.filter(
+    (edge) => edge.to === 'tool:acme.shared' && edge.kind === 'uses-tool',
+  );
+  assert.equal(usesToolEdges.length, 2);
+  assert.deepEqual(bundle.heads, [
+    { type: 'agent', id: left.id },
+    { type: 'agent', id: right.id },
+    { type: 'tool', id: 'acme.shared' },
+  ]);
+});
+
 test('rest handlers round-trip a share: preview exports a bundle and install recreates it', async () => {
   const { handlePreview, handleInstall } = require('../agent-bundles/rest');
   const automation = createAutomation({

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

@@ -5,12 +5,16 @@ const assert = require('node:assert/strict');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { spawnSync } = require('child_process');
 const yaml = require('js-yaml');
 
 const {
   absoluteAssetUrl,
   applyDesktopReleaseEnv,
+  appBuilderBinaryPath,
+  appBuilderBinaryRelativePath,
   bridgeChannelInfoForBase,
+  codesignIdentityForCli,
   desktopLegacyBridgePlan,
   desktopLegacyBridgeRepository,
   desktopReleaseArtifactPaths,
@@ -21,9 +25,12 @@ const {
   desktopUpdateUrlForLane,
   desktopVersion,
   envForBuild,
+  manualDesktopNotarizationEnabled,
+  notarytoolCredentialArgs,
   parseEnvFile,
   parseUploadOffsetMismatch,
   publishDesktopRelease,
+  recreateZipFromAppBundle,
   recoverableUploadOffset,
   requestFromEnv,
   shouldHandleRequest,
@@ -205,6 +212,24 @@ test('desktop release runner uses electron-builder compatible signing identity n
   assert.equal(env.AMALGM_DESKTOP_RELEASE_FLY_APP, 'amalgm-desktop-releases');
   assert.equal(env.AMALGM_DESKTOP_RELEASE_FLY_ROOT, '/data');
   assert.equal(env.AMALGM_DESKTOP_THIN, '1');
+  assert.equal(env.AMALGM_DESKTOP_NOTARIZE, 'off');
+});
+
+test('desktop release runner preserves explicit bundled desktop builds', () => {
+  const env = envForBuild(
+    {
+      GH_TOKEN: 'token',
+      AMALGM_DESKTOP_THIN: '0',
+    },
+    { lane: 'main', delivery: 'delivery-id' },
+    '0.1.124',
+    '0.1.124000001',
+    { engineRef: 'engine', uiRef: 'ui' },
+    { engineSha: 'engine-sha', uiSha: 'ui-sha' },
+    'https://amalgm.ai',
+  );
+
+  assert.equal(env.AMALGM_DESKTOP_THIN, '0');
 });
 
 test('desktop release runner omits blank certificate file secrets', () => {
@@ -226,6 +251,120 @@ test('desktop release runner omits blank certificate file secrets', () => {
   assert.equal(env.CSC_NAME, 'amalgm, Inc. (C5S6UATV3L)');
 });
 
+test('desktop release runner manual notarization can be disabled explicitly', () => {
+  assert.equal(manualDesktopNotarizationEnabled({}), true);
+  assert.equal(manualDesktopNotarizationEnabled({
+    AMALGM_DESKTOP_RELEASE_MANUAL_NOTARIZE: '0',
+  }), false);
+
+  const env = envForBuild(
+    {
+      GH_TOKEN: 'token',
+      AMALGM_DESKTOP_RELEASE_MANUAL_NOTARIZE: '0',
+      AMALGM_DESKTOP_NOTARIZE: 'required',
+    },
+    { lane: 'main', delivery: 'delivery-id' },
+    '0.1.124',
+    '0.1.124000001',
+    { engineRef: 'engine', uiRef: 'ui' },
+    { engineSha: 'engine-sha', uiSha: 'ui-sha' },
+    'https://amalgm.ai',
+  );
+  assert.equal(env.AMALGM_DESKTOP_NOTARIZE, 'required');
+});
+
+test('desktop release runner resolves manual notarization credentials and CLI identity', () => {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-desktop-release-notary-'));
+  const keyPath = path.join(tempRoot, 'AuthKey_TEST.p8');
+  fs.writeFileSync(keyPath, 'dummy-key');
+
+  try {
+    assert.deepEqual(notarytoolCredentialArgs({
+      APPLE_API_KEY: keyPath,
+      APPLE_API_KEY_ID: 'KEYID123',
+      APPLE_API_ISSUER: 'issuer-123',
+    }), {
+      args: ['--key', keyPath, '--key-id', 'KEYID123', '--issuer', 'issuer-123'],
+      credentialType: 'api-key',
+    });
+
+    assert.deepEqual(notarytoolCredentialArgs({
+      APPLE_ID: 'user@example.com',
+      APPLE_APP_SPECIFIC_PASSWORD: 'app-password',
+      APPLE_TEAM_ID: 'TEAM123',
+    }), {
+      args: ['--apple-id', 'user@example.com', '--password', 'app-password', '--team-id', 'TEAM123'],
+      credentialType: 'apple-id',
+    });
+
+    assert.equal(
+      codesignIdentityForCli({ CSC_NAME: 'amalgm, Inc. (C5S6UATV3L)' }),
+      'Developer ID Application: amalgm, Inc. (C5S6UATV3L)',
+    );
+  assert.equal(
+    codesignIdentityForCli({ CSC_NAME: 'Developer ID Application: amalgm, Inc. (C5S6UATV3L)' }),
+    'Developer ID Application: amalgm, Inc. (C5S6UATV3L)',
+  );
+  assert.equal(
+    appBuilderBinaryRelativePath('darwin', 'arm64'),
+    path.join('mac', 'app-builder_arm64'),
+  );
+  assert.equal(
+    appBuilderBinaryRelativePath('darwin', 'x64'),
+    path.join('mac', 'app-builder_amd64'),
+  );
+  assert.equal(
+    appBuilderBinaryRelativePath('linux', 'arm64'),
+    path.join('linux', 'arm64', 'app-builder'),
+  );
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+});
+
+test('desktop release runner resolves app-builder binary path from checkout node_modules or override', () => {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-desktop-release-app-builder-'));
+  const engineDir = path.join(tempRoot, 'engine');
+  const binaryPath = path.join(engineDir, 'node_modules', 'app-builder-bin', 'mac', 'app-builder_arm64');
+  fs.mkdirSync(path.dirname(binaryPath), { recursive: true });
+  fs.writeFileSync(binaryPath, '');
+
+  try {
+    assert.equal(
+      appBuilderBinaryPath(engineDir, {}, 'darwin', 'arm64'),
+      binaryPath,
+    );
+    assert.equal(
+      appBuilderBinaryPath(engineDir, { AMALGM_DESKTOP_APP_BUILDER_BIN: '/tmp/custom-app-builder' }, 'darwin', 'arm64'),
+      '/tmp/custom-app-builder',
+    );
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+});
+
+test('desktop release runner recreates updater zip from app bundle', () => {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-desktop-release-zip-'));
+  const engineDir = path.join(tempRoot, 'engine');
+  const appPath = path.join(engineDir, 'build', 'mac-arm64', 'amalgm-preview.app');
+  const markerPath = path.join(appPath, 'Contents', 'Resources', 'marker.txt');
+  const zipPath = path.join(engineDir, 'build', 'amalgm-preview-0.1.1-arm64.zip');
+  fs.mkdirSync(path.dirname(markerPath), { recursive: true });
+  fs.writeFileSync(markerPath, 'fresh app payload');
+  fs.writeFileSync(zipPath, 'old zip payload');
+
+  try {
+    recreateZipFromAppBundle(engineDir, appPath, zipPath, {});
+    assert.ok(fs.statSync(zipPath).size > 'old zip payload'.length);
+
+    const listing = spawnSync('unzip', ['-l', zipPath], { encoding: 'utf8' });
+    assert.equal(listing.status, 0, listing.stderr);
+    assert.match(listing.stdout, /amalgm-preview\.app\/Contents\/Resources\/marker\.txt/);
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+});
+
 test('desktop release repository can be overridden as owner/repo or full name', () => {
   assert.deepEqual(desktopReleaseRepository({
     AMALGM_DESKTOP_UPDATE_OWNER: 'example',