amalgm 0.1.141 → 0.1.142

package/package.json

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

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

@@ -25,6 +25,16 @@ function cleanString(value) {
   return typeof value === 'string' ? value.trim() : '';
 }
 
+function uniqueToolIds(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const item of value) {
+    const id = cleanString(item);
+    if (id && !out.includes(id)) out.push(id);
+  }
+  return out;
+}
+
 const NODE_INSTALL_COMMANDS = [
   ['pnpm-lock.yaml', 'pnpm install --frozen-lockfile'],
   ['yarn.lock', 'yarn install --frozen-lockfile'],
@@ -84,6 +94,9 @@ function exportAppEntry(appId, options = {}) {
         autostart: app.autostart !== false,
         keepAlive: app.keepAlive !== false,
       },
+      // Tools that belong to this app; ids are stable across install, so the
+      // recipient's registration points at the same tool ids.
+      toolIds: uniqueToolIds(app.toolIds),
       files: packed.files,
       totalBytes: packed.totalBytes,
       skipped: packed.skipped,
@@ -133,8 +146,11 @@ function materializeAppEntry(entry, options = {}) {
     cwd: targetDir,
     build_command: buildCommand,
     start_command: entry.app.startCommand,
-    autostart: entry.app.autostart !== false,
-    keep_alive: entry.app.keepAlive !== false,
+    tool_ids: uniqueToolIds(entry.toolIds),
+    // A downloaded app is a fresh registration: it should come up now and
+    // keep coming back with the recipient runtime.
+    autostart: true,
+    keep_alive: true,
   };
 }
 

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

@@ -7,6 +7,7 @@ const { normalizeAgentConfig } = require('../agent-config/schema');
 const { createAgent, getAllAgentsWithBuiltins, resolveAgent } = require('../agents/store');
 const { hydrateConfigSkills } = require('../skills/store');
 const { defaultToolboxService } = require('../toolbox/service');
+const { getApp } = require('../apps/store');
 const { exportAutomationEntry, installAutomationEntry } = require('./automation-entries');
 const { exportAppEntry, installAppEntry } = require('./app-entries');
 const { annotateAppBoundPaths, rewriteAppBoundPaths } = require('./tool-bindings');
@@ -298,6 +299,20 @@ function buildFlatAgentBundleGraph(bundle) {
       });
     }
   }
+  // Tools that belong to an app render nested under it in the share sidebar;
+  // the canonical tool record still appears exactly once.
+  for (const entry of bundle.apps || []) {
+    const currentAppId = appEntryId(entry);
+    if (!currentAppId) continue;
+    for (const toolId of uniqueStrings(entry.toolIds)) {
+      includedToolIds.add(toolId);
+      pushGraphEdge(edges, {
+        from: graphElementId('app', currentAppId),
+        to: graphElementId('tool', toolId),
+        kind: 'uses-tool',
+      });
+    }
+  }
   for (const entry of bundle.agents || []) {
     const currentAgentId = agentEntryId(entry);
     if (!currentAgentId) continue;
@@ -605,17 +620,39 @@ function createBundle(input = {}, options = {}) {
     for (const ref of exported.missingRefs) addUnique(requires.missingTools, ref);
   }
 
+  // Tool → app closure: an app-owned tool only works next to its app, so any
+  // requested tool whose record points at an app pulls that app in as a
+  // dependency (not a head). Stale pointers degrade to a warning.
+  const appLinkWarnings = [];
+  const dependencyAppIds = [];
+  const catalog = defaultToolboxService.readCatalog();
+  for (const selectedId of uniqueStrings([...loadoutToolIds, ...toolIds])) {
+    const selectedAction = catalog.toolActions?.[selectedId];
+    const tool = catalog.tools?.[selectedId]
+      || (selectedAction ? catalog.tools?.[selectedAction.toolId] : null);
+    const owningAppId = typeof tool?.appId === 'string' ? tool.appId.trim() : '';
+    if (!owningAppId || appIds.includes(owningAppId) || dependencyAppIds.includes(owningAppId)) continue;
+    if (!getApp(owningAppId)) {
+      appLinkWarnings.push(`Tool ${tool.id} belongs to app ${owningAppId}, which no longer exists; the app was not bundled.`);
+      continue;
+    }
+    dependencyAppIds.push(owningAppId);
+  }
+
   const apps = [];
   const appCwdBySourceId = new Map();
   let skippedAppFiles = 0;
-  for (const appId of appIds) {
+  const appToolIds = [];
+  for (const appId of [...appIds, ...dependencyAppIds]) {
     const exported = exportAppEntry(appId);
     apps.push(exported.entry);
     appCwdBySourceId.set(exported.entry.sourceAppId, exported.sourceCwd);
     skippedAppFiles += exported.skipped.length;
+    // App → tool closure: tools that belong to a bundled app travel with it.
+    appToolIds.push(...(exported.entry.toolIds || []));
   }
 
-  const { tools, toolActions } = collectToolRecords([...loadoutToolIds, ...toolIds], requires);
+  const { tools, toolActions } = collectToolRecords([...loadoutToolIds, ...appToolIds, ...toolIds], requires);
 
   // Tool files that live inside a shared app travel with that app: record
   // app-relative bindings so install rewrites them to the recipient's copy.
@@ -636,14 +673,20 @@ function createBundle(input = {}, options = {}) {
   const sharedTools = sharedToolIds.map((toolId) => tools.find((tool) => tool.id === toolId));
   const skills = collectSkillRecords(agents);
   const hooks = countHooks(agents);
-  const warnings = bundleWarnings({
-    hooks,
-    tools: tools.length,
-    automations: automations.length,
-    apps: apps.length,
-    skippedAppFiles,
-  });
-  const { title, description } = bundleTitleAndDescription(agents, automations, apps, sharedTools);
+  const warnings = [
+    ...bundleWarnings({
+      hooks,
+      tools: tools.length,
+      automations: automations.length,
+      apps: apps.length,
+      skippedAppFiles,
+    }),
+    ...appLinkWarnings,
+  ];
+  // Title comes from what the user deliberately shared: dependency apps
+  // pulled in by an app-owned tool must not name the bundle.
+  const headApps = apps.filter((entry) => appIds.includes(entry.sourceAppId));
+  const { title, description } = bundleTitleAndDescription(agents, automations, headApps, sharedTools);
   const heads = [
     ...agentIds.map((id) => ({ type: 'agent', id })),
     ...automationIds.map((id) => ({ type: 'automation', id })),
@@ -808,7 +851,7 @@ function validateBundle(bundle) {
   return withBundleGraph(bundle);
 }
 
-function installTools(bundle, appDirBySourceId = new Map()) {
+function installTools(bundle, appDirBySourceId = new Map(), appIdBySourceId = new Map()) {
   const warnings = [];
   const rewrite = (record) => {
     const result = rewriteAppBoundPaths(record, appDirBySourceId);
@@ -827,8 +870,20 @@ function installTools(bundle, appDirBySourceId = new Map()) {
   const installed = [];
   for (const tool of Array.isArray(bundle.tools) ? bundle.tools : []) {
     if (!tool?.id || tool.origin === 'system') continue;
+    const record = rewrite(tool);
+    // The app link travels by source app id; point it at the recipient's
+    // installed copy, or drop it if that app was not part of the install.
+    if (typeof record.appId === 'string' && record.appId) {
+      const installedAppId = appIdBySourceId.get(record.appId);
+      if (installedAppId) {
+        record.appId = installedAppId;
+      } else {
+        delete record.appId;
+        warnings.push(`Tool ${tool.id} belongs to an app that was not installed with this bundle; the app link was removed.`);
+      }
+    }
     const result = defaultToolboxService.registerTool({
-      ...rewrite(tool),
+      ...record,
       origin: tool.origin === 'catalog' ? 'catalog' : 'user',
       actions: toolActionsByToolId.get(tool.id) || [],
     });
@@ -912,17 +967,19 @@ async function installBundle(input, options = {}) {
 
   const installedApps = [];
   const appDirBySourceId = new Map();
+  const appIdBySourceId = new Map();
   const appEntries = Array.isArray(bundle.apps) ? bundle.apps : [];
   if (appEntries.length > 0) {
     const rootDir = options.appsRootDir || defaultAppsInstallRoot();
     for (const entry of appEntries) {
       const installed = await installAppEntry(entry, { rootDir, register: options.registerApp });
       appDirBySourceId.set(appEntryId(entry), installed.cwd);
+      if (installed.id) appIdBySourceId.set(appEntryId(entry), installed.id);
       installedApps.push(installed);
     }
   }
 
-  const { installed: installedTools, warnings: bindingWarnings } = installTools(bundle, appDirBySourceId);
+  const { installed: installedTools, warnings: bindingWarnings } = installTools(bundle, appDirBySourceId, appIdBySourceId);
   const { idMap, installedAgents } = installBundleAgents(bundle, options);
 
   const installedAutomations = [];

package/runtime/scripts/amalgm-mcp/apps/store.js

@@ -42,6 +42,16 @@ function genAppRef() {
   return out;
 }
 
+function normalizeAppToolIds(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const item of value) {
+    const id = typeof item === 'string' ? item.trim() : '';
+    if (id && !out.includes(id)) out.push(id);
+  }
+  return out;
+}
+
 function normalizeApp(app) {
   const appRef = app.appRef || app.app_ref || app.artifactRef || app.artifact_ref || genAppRef();
   const savedUrl = app.appUrl || app.publicUrl || '';
@@ -64,6 +74,9 @@ function normalizeApp(app) {
     dnsConnected,
     autostart: app.autostart !== false,
     keepAlive: app.keepAlive !== false,
+    // Toolbox tools that belong to this app: they travel with the app when it
+    // is shared, and the app travels with them when one of them is shared.
+    toolIds: normalizeAppToolIds(app.toolIds ?? app.tool_ids),
     desiredState: app.desiredState || (app.status === 'stopped' ? 'stopped' : 'running'),
     status: app.status || 'stopped',
     pid: app.pid || null,

package/runtime/scripts/amalgm-mcp/apps/supervisor.js

@@ -421,6 +421,7 @@ async function registerApp(input) {
     dnsConnected: input.connect_dns !== false,
     autostart: input.autostart !== false,
     keepAlive: input.keep_alive !== false,
+    toolIds: Array.isArray(input.tool_ids || input.toolIds) ? (input.tool_ids || input.toolIds) : [],
     desiredState: 'running',
     status: 'registered',
     pid: null,

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

@@ -647,6 +647,17 @@ function ensureCheckout({ dir, repoUrl, branch, ref }) {
 }
 
 function resolveBuildRefs(request) {
+  const explicitEngineRef = cleanString(process.env.AMALGM_DESKTOP_RELEASE_ENGINE_REF);
+  const explicitUiRef = cleanString(process.env.AMALGM_DESKTOP_RELEASE_UI_REF);
+  if (explicitEngineRef || explicitUiRef) {
+    if (!explicitEngineRef || !explicitUiRef) {
+      throw new Error('Explicit desktop release refs require both AMALGM_DESKTOP_RELEASE_ENGINE_REF and AMALGM_DESKTOP_RELEASE_UI_REF.');
+    }
+    return {
+      engineRef: explicitEngineRef,
+      uiRef: explicitUiRef,
+    };
+  }
   const branch = request.branch;
   return {
     engineRef: request.repository === ENGINE_REPO_FULL_NAME ? request.after : branch,

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

@@ -224,7 +224,12 @@ test('materializeAppEntry bootstraps node dependencies for imported apps without
 test('mixed bundle carries automations and apps with heads and installs everything', async () => {
   const dir = makeTempDir('bundle-mixed-app-');
   writeSampleApp(dir);
-  const app = registerSampleApp(dir);
+  const app = registerSampleApp(dir, {
+    autostart: false,
+    keepAlive: false,
+    desiredState: 'stopped',
+    status: 'stopped',
+  });
   const automation = createAutomation({
     name: 'Mixed Bundle Automation',
     triggers: [{ kind: 'scheduled', schedule: { kind: 'cron', expr: '30 6 * * *', tz: 'UTC' } }],
@@ -250,6 +255,8 @@ test('mixed bundle carries automations and apps with heads and installs everythi
   assert.equal(preview.automations.length, 1);
   assert.equal(preview.apps.length, 1);
   assert.equal(preview.apps[0].files, 4);
+  assert.equal(bundle.apps[0].app.autostart, false);
+  assert.equal(bundle.apps[0].app.keepAlive, false);
 
   // Round-trip through JSON like the storage path does.
   const revived = JSON.parse(JSON.stringify(bundle));
@@ -271,6 +278,8 @@ test('mixed bundle carries automations and apps with heads and installs everythi
   assert.equal(result.installedApps.length, 1);
   assert.equal(listAutomations().length, before + 1);
   assert.equal(registered.length, 1);
+  assert.equal(registered[0].autostart, true);
+  assert.equal(registered[0].keep_alive, true);
   assert.equal(fs.existsSync(path.join(registered[0].cwd, 'src', 'index.js')), true);
 });
 
@@ -536,6 +545,179 @@ test('app-backed tool paths still bind when the tool uses a symlink alias of the
   assert.equal(bundle.requires.bindings.some((entry) => entry.includes('appbound.alias.tool')), false);
 });
 
+test('sharing an app pulls its owned tools, nested under the app in the graph', async () => {
+  const { defaultToolboxService } = require('../toolbox/service');
+  const appDir = makeTempDir('bundle-appowned-src-');
+  fs.mkdirSync(path.join(appDir, 'tool'), { recursive: true });
+  fs.writeFileSync(path.join(appDir, 'package.json'), JSON.stringify({ name: 'appowned' }));
+  fs.writeFileSync(path.join(appDir, 'server.js'), 'console.log("serve");\n');
+  fs.writeFileSync(path.join(appDir, 'tool', 'cli.mjs'), 'console.log("tool");\n');
+
+  const app = registerSampleApp(appDir, {
+    id: 'app-owned-test',
+    name: 'App Owned',
+    appRef: 'appownedref01',
+    startCommand: 'PORT={port} node server.js',
+    toolIds: ['appowned.tool'],
+  });
+  defaultToolboxService.registerTool({
+    id: 'appowned.tool',
+    name: 'App Owned Tool',
+    type: 'cli',
+    origin: 'user',
+    appId: app.id,
+    source: {
+      command: 'node',
+      args: [path.join(appDir, 'tool', 'cli.mjs')],
+      cwd: appDir,
+      inputMode: 'json-stdin',
+      outputMode: 'json',
+    },
+  });
+
+  // Share only the app: the owned tool comes along as a dependency, not a head.
+  const { bundle } = createBundle({ appIds: [app.id] });
+  assert.deepEqual(bundle.heads, [{ type: 'app', id: app.id }]);
+  assert.equal(bundle.tools.filter((tool) => tool.id === 'appowned.tool').length, 1);
+  assert.equal(bundle.tools[0].appId, app.id);
+  assert.deepEqual(
+    bundle.edges.filter((edge) => edge.kind === 'uses-tool' && edge.from === `app:${app.id}`),
+    [{ from: `app:${app.id}`, to: 'tool:appowned.tool', kind: 'uses-tool' }],
+  );
+  // The tool's paths bind to the app, so nothing stays machine-bound.
+  assert.equal(bundle.requires.bindings.some((entry) => entry.includes('appowned.tool')), false);
+
+  const revived = JSON.parse(JSON.stringify(bundle));
+  validateBundle(revived);
+
+  // Install: the registered app carries its tool ids, and the installed
+  // tool's app link points at the recipient's app, not the sharer's.
+  defaultToolboxService.deleteTool('appowned.tool');
+  const rootDir = makeTempDir('bundle-appowned-install-');
+  const registered = [];
+  const result = await installBundle(revived, {
+    appsRootDir: rootDir,
+    registerApp: async (input) => {
+      registered.push(input);
+      return { id: 'app-installed-owned', ...input, status: 'running' };
+    },
+  });
+  assert.deepEqual(registered[0].tool_ids, ['appowned.tool']);
+  const installedTool = result.installedTools.find((tool) => tool.id === 'appowned.tool');
+  assert.equal(installedTool.appId, 'app-installed-owned');
+  assert.equal(installedTool.source.cwd, result.installedApps[0].cwd);
+});
+
+test('sharing an app-owned tool pulls the app as a dependency, not a head', async () => {
+  const { defaultToolboxService } = require('../toolbox/service');
+  const appDir = makeTempDir('bundle-toolowner-src-');
+  fs.writeFileSync(path.join(appDir, 'package.json'), JSON.stringify({ name: 'toolowner' }));
+  fs.writeFileSync(path.join(appDir, 'server.js'), 'console.log("serve");\n');
+  fs.writeFileSync(path.join(appDir, 'cli.mjs'), 'console.log("tool");\n');
+
+  const app = registerSampleApp(appDir, {
+    id: 'app-toolowner-test',
+    name: 'Tool Owner App',
+    appRef: 'toolownerref1',
+    startCommand: 'PORT={port} node server.js',
+    toolIds: ['toolowner.tool'],
+  });
+  defaultToolboxService.registerTool({
+    id: 'toolowner.tool',
+    name: 'Tool Owner Tool',
+    type: 'cli',
+    origin: 'user',
+    appId: app.id,
+    source: {
+      command: 'node',
+      args: [path.join(appDir, 'cli.mjs')],
+      cwd: appDir,
+      inputMode: 'json-stdin',
+      outputMode: 'json',
+    },
+  });
+
+  const { bundle } = createBundle({ toolIds: ['toolowner.tool'] });
+  // The tool is the only head; the app rides along and does not name the bundle.
+  assert.deepEqual(bundle.heads, [{ type: 'tool', id: 'toolowner.tool' }]);
+  assert.equal(bundle.title, 'Tool Owner Tool');
+  assert.equal(bundle.apps.length, 1);
+  assert.equal(bundle.apps[0].sourceAppId, app.id);
+  assert.deepEqual(bundle.apps[0].toolIds, ['toolowner.tool']);
+  assert.equal(bundle.edges.some(
+    (edge) => edge.from === `app:${app.id}` && edge.to === 'tool:toolowner.tool' && edge.kind === 'uses-tool',
+  ), true);
+  // App-bound paths resolve through the pulled-in app.
+  const toolEntry = bundle.tools.find((tool) => tool.id === 'toolowner.tool');
+  assert.equal(Array.isArray(toolEntry.appPathBindings), true);
+  assert.equal(bundle.requires.bindings.some((entry) => entry.includes('toolowner.tool')), false);
+  validateBundle(JSON.parse(JSON.stringify(bundle)));
+});
+
+test('an agent using an app-owned tool stays canonical: one tool record, app pulled once', () => {
+  const { createAgent } = require('../agents/store');
+  const { upsertAgentConfig } = require('../agent-config/store');
+  const { defaultToolboxService } = require('../toolbox/service');
+
+  const appDir = makeTempDir('bundle-agentapp-src-');
+  fs.writeFileSync(path.join(appDir, 'package.json'), JSON.stringify({ name: 'agentapp' }));
+  fs.writeFileSync(path.join(appDir, 'server.js'), 'console.log("serve");\n');
+  const app = registerSampleApp(appDir, {
+    id: 'app-agentapp-test',
+    name: 'Agent App',
+    appRef: 'agentappref01',
+    startCommand: 'PORT={port} node server.js',
+    toolIds: ['agentapp.tool'],
+  });
+  defaultToolboxService.registerTool({
+    id: 'agentapp.tool',
+    name: 'Agent App Tool',
+    type: 'cli',
+    origin: 'user',
+    appId: app.id,
+    source: { command: 'agentapp-tool', inputMode: 'json-stdin', outputMode: 'json' },
+  });
+  const agent = createAgent({
+    id: 'agentapp-agent',
+    name: 'Agent App User',
+    baseHarnessId: 'codex',
+    loadout: { toolIds: ['agentapp.tool'] },
+    authMethod: 'amalgm',
+  });
+  upsertAgentConfig(agent.id, { instructions: 'use the app tool', loadout: { toolIds: ['agentapp.tool'] } });
+
+  const { bundle } = createBundle({ agentIds: [agent.id] });
+  // Agent head only; the tool pulled the app, the app re-listed the tool —
+  // still one tool record, one app entry, and one edge per relationship.
+  assert.deepEqual(bundle.heads, [{ type: 'agent', id: agent.id }]);
+  assert.equal(bundle.title, 'Agent App User');
+  assert.equal(bundle.tools.filter((tool) => tool.id === 'agentapp.tool').length, 1);
+  assert.equal(bundle.apps.length, 1);
+  assert.equal(
+    bundle.elements.filter((element) => element.id === 'tool:agentapp.tool').length,
+    1,
+  );
+  const toolEdges = bundle.edges.filter((edge) => edge.to === 'tool:agentapp.tool' && edge.kind === 'uses-tool');
+  assert.deepEqual(toolEdges.map((edge) => edge.from).sort(), [`agent:${agent.id}`, `app:${app.id}`]);
+});
+
+test('a stale tool→app link degrades to a warning instead of failing the export', () => {
+  const { defaultToolboxService } = require('../toolbox/service');
+  defaultToolboxService.registerTool({
+    id: 'stale.applink',
+    name: 'Stale App Link',
+    type: 'cli',
+    origin: 'user',
+    appId: 'app-that-was-deleted',
+    source: { command: 'stale-applink', inputMode: 'json-stdin', outputMode: 'json' },
+  });
+
+  const { bundle } = createBundle({ toolIds: ['stale.applink'] });
+  assert.equal(bundle.apps.length, 0);
+  assert.equal(bundle.tools.length, 1);
+  assert.equal(bundle.warnings.some((warning) => warning.includes('app-that-was-deleted')), true);
+});
+
 test('installBundle defaults app materialization to the owned apps root', async () => {
   const appDir = makeTempDir('bundle-appsroot-src-');
   fs.writeFileSync(path.join(appDir, 'package.json'), JSON.stringify({ name: 'appsroot' }));

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

@@ -92,6 +92,38 @@ test('desktop release runner maps UI pushes to UI SHA plus engine branch', () =>
   });
 });
 
+test('desktop release runner honors explicit engine and UI ref overrides', () => {
+  const previousEngineRef = process.env.AMALGM_DESKTOP_RELEASE_ENGINE_REF;
+  const previousUiRef = process.env.AMALGM_DESKTOP_RELEASE_UI_REF;
+
+  try {
+    process.env.AMALGM_DESKTOP_RELEASE_ENGINE_REF = '4'.repeat(40);
+    process.env.AMALGM_DESKTOP_RELEASE_UI_REF = '5'.repeat(40);
+
+    const request = requestFromEnv({
+      AMALGM_DESKTOP_RELEASE_DRY_RUN: '1',
+      AMALGM_DESKTOP_RELEASE_SOURCE_REPO: 'amalgm-inc/amalgm-engine',
+      AMALGM_DESKTOP_RELEASE_REF: 'refs/heads/main',
+      AMALGM_DESKTOP_RELEASE_AFTER: '3'.repeat(40),
+    });
+
+    const result = publishDesktopRelease(request, {
+      checkoutRoot: '/tmp/amalgm-desktop-release-test',
+    });
+
+    assert.equal(result.dryRun, true);
+    assert.deepEqual(result.refs, {
+      engineRef: '4'.repeat(40),
+      uiRef: '5'.repeat(40),
+    });
+  } finally {
+    if (previousEngineRef === undefined) delete process.env.AMALGM_DESKTOP_RELEASE_ENGINE_REF;
+    else process.env.AMALGM_DESKTOP_RELEASE_ENGINE_REF = previousEngineRef;
+    if (previousUiRef === undefined) delete process.env.AMALGM_DESKTOP_RELEASE_UI_REF;
+    else process.env.AMALGM_DESKTOP_RELEASE_UI_REF = previousUiRef;
+  }
+});
+
 test('desktop release runner skips irrelevant pushes and branch deletions', () => {
   assert.equal(shouldHandleRequest({
     repository: 'amalgm-inc/amalgm-engine',

package/runtime/scripts/amalgm-mcp/toolbox/store.js

@@ -352,6 +352,9 @@ function normalizeTool(input, existing) {
     name,
     type,
     owner: normalizeOwner(input.owner || input.toolOwner || input.ownership || input.policy?.owner),
+    // Reverse pointer to the app this tool belongs to (app.toolIds is the
+    // forward edge): sharing either side pulls the other into the bundle.
+    ...(nonEmptyString(input.appId) ? { appId: input.appId.trim() } : {}),
     origin: TOOL_ORIGINS.has(input.origin) ? input.origin : 'user',
     status: RECORD_STATUSES.has(input.status) ? input.status : 'enabled',
     source: normalizeSource(type, isObject(input.source) ? input.source : input),