amalgm 0.1.88 → 0.1.89

package/runtime/scripts/chat-core/tooling/system-prompt.js

@@ -1,14 +1,42 @@
 'use strict';
 
 const { PLATFORM_CONTEXT } = require('../../chat-server/config');
-const { activeMemoryContextBlock, instructionsContextBlock } = require('./active-memory');
-const { passiveMemoryContextBlock } = require('./passive-memory');
 const { renderAgentInstructions } = require('../../amalgm-mcp/agent-config/renderers/instructions');
 
 function trimBlock(value) {
   return String(value || '').trim();
 }
 
+// Fresh provider threads carry the full project context in the system prompt;
+// resumed threads receive per-turn <project_context_update> blocks instead
+// (see input.js). The block gates itself on contract.providerSessionId, and a
+// failure here must never break prompt composition.
+function projectContextBlock(contract) {
+  try {
+    return require('../../amalgm-mcp/project-context/prompt').projectContextPromptBlock(contract);
+  } catch (error) {
+    const message = error instanceof Error ? error.message.split('\n')[0] : String(error);
+    console.warn('[chat-core] project context block failed:', message);
+    return '';
+  }
+}
+
+function systemInstructionsBlockSafe() {
+  try {
+    return require('./system-instructions').systemInstructionsBlock();
+  } catch (error) {
+    const message = error instanceof Error ? error.message.split('\n')[0] : String(error);
+    console.warn('[chat-core] system instructions block failed:', message);
+    return '';
+  }
+}
+
+/**
+ * Definitive memory model: platform context, system instructions
+ * (machine-wide, user-authored), project context (instructions + project
+ * state + recent change log, maintained through the memories tool), and the
+ * agent's own instructions. The legacy active/passive memory blocks are gone.
+ */
 function composeSystemPrompt(contract) {
   const parts = [];
   const platform = trimBlock(PLATFORM_CONTEXT);
@@ -16,13 +44,11 @@ function composeSystemPrompt(contract) {
     trimBlock(contract?.compiledAgentInstructions)
     || trimBlock(renderAgentInstructions(contract?.agentConfig, { includeAgentToAgentPrompt: false }));
   const custom = compiledAgentInstructions || trimBlock(contract?.systemPrompt);
-  const instructions = contract?.providerSessionId ? '' : trimBlock(instructionsContextBlock(contract));
-  const active = contract?.providerSessionId ? '' : trimBlock(activeMemoryContextBlock(contract));
-  const passive = contract?.providerSessionId ? '' : trimBlock(passiveMemoryContextBlock());
+  const systemInstructions = contract?.providerSessionId ? '' : trimBlock(systemInstructionsBlockSafe());
+  const projectContext = trimBlock(projectContextBlock(contract));
   if (platform) parts.push(platform);
-  if (instructions) parts.push(instructions);
-  if (active) parts.push(active);
-  if (passive) parts.push(passive);
+  if (systemInstructions) parts.push(systemInstructions);
+  if (projectContext) parts.push(projectContext);
   if (custom) parts.push(custom);
   return parts.join('\n\n');
 }

package/runtime/scripts/local-gateway.js

@@ -143,6 +143,7 @@ const MCP_PREFIXES = [
   '/automations',
   '/event-triggers',
   '/workspace',
+  '/project-context',
   '/github',
   '/fs',
   '/mcp-connections',

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

@@ -1,569 +0,0 @@
-const crypto = require('crypto');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { spawn } = require('child_process');
-
-const DEFAULT_TIMEOUT_MS = 120_000;
-const DEFAULT_SESSION = 'default';
-const activeRecordings = new Map();
-const knownSessions = new Map();
-
-function amalgmDir() {
-  return process.env.AMALGM_DIR || path.join(os.homedir(), '.amalgm');
-}
-
-function ensureDir(dir) {
-  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-  try { fs.chmodSync(dir, 0o700); } catch {}
-  return dir;
-}
-
-function safeId(value, fallback = DEFAULT_SESSION) {
-  const raw = String(value || fallback).replace(/^agent-browser:/, '');
-  return raw.replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 96) || fallback;
-}
-
-function browserRoot() {
-  return ensureDir(path.join(amalgmDir(), 'browser'));
-}
-
-function profileDir(session) {
-  return ensureDir(path.join(browserRoot(), 'profiles', session));
-}
-
-function screenshotDir() {
-  return ensureDir(path.join(browserRoot(), 'screenshots'));
-}
-
-function recordingDir(session) {
-  return ensureDir(path.join(amalgmDir(), 'browser-sessions', session));
-}
-
-function browserSession(args = {}, context = {}) {
-  return safeId(
-    args.browserProfileId
-      || args.profileId
-      || args.browserSessionId
-      || args.sessionId
-      || args.tabId
-      || context?.callerSessionId
-      || DEFAULT_SESSION,
-  );
-}
-
-function rememberBrowserProfile(session, input = {}) {
-  try {
-    require('./profiles').touchBrowserProfile({
-      id: session,
-      name: input.name || input.profileName || input.browserProfileName || session,
-      source: 'agent-browser',
-      profilePath: profileDir(session),
-    }, { source: 'agent-browser' });
-  } catch (error) {
-    if (process.env.AMALGM_DEBUG_BROWSER_PROFILE_STORE) {
-      console.warn('[agent-browser] Failed to record browser profile:', error.message);
-    }
-  }
-}
-
-function tabInfo(session, extra = {}) {
-  rememberBrowserProfile(session, extra);
-  const info = {
-    tabId: `agent-browser:${session}`,
-    browserSessionId: session,
-    browserProfileId: session,
-    backend: 'agent-browser',
-    ...extra,
-  };
-  knownSessions.set(session, { ...knownSessions.get(session), ...info, lastActiveAt: Date.now() });
-  return info;
-}
-
-function agentBrowserCommand() {
-  if (process.env.AMALGM_AGENT_BROWSER_BIN) {
-    return { command: process.env.AMALGM_AGENT_BROWSER_BIN, prefix: [] };
-  }
-
-  try {
-    return {
-      command: process.execPath,
-      prefix: [require.resolve('agent-browser/bin/agent-browser.js')],
-    };
-  } catch {
-    return { command: 'agent-browser', prefix: [] };
-  }
-}
-
-function wantsHeaded() {
-  const explicit = process.env.AMALGM_BROWSER_HEADED || process.env.AGENT_BROWSER_HEADED;
-  if (explicit) return !/^(0|false|no)$/i.test(explicit);
-  if (/^(1|true|yes)$/i.test(process.env.AMALGM_BROWSER_HEADLESS || '')) return false;
-  if (process.platform === 'linux' && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) return false;
-  return true;
-}
-
-function baseArgs(session, json = true) {
-  const args = [
-    '--session', session,
-    '--profile', profileDir(session),
-    '--screenshot-dir', screenshotDir(),
-  ];
-
-  if (json) args.push('--json');
-  if (wantsHeaded()) args.push('--headed');
-  if (process.env.AMALGM_BROWSER_EXECUTABLE_PATH) {
-    args.push('--executable-path', process.env.AMALGM_BROWSER_EXECUTABLE_PATH);
-  }
-  if (process.env.AMALGM_BROWSER_PROVIDER) {
-    args.push('--provider', process.env.AMALGM_BROWSER_PROVIDER);
-  }
-
-  return args;
-}
-
-function parseJson(stdout) {
-  const text = String(stdout || '').trim();
-  if (!text) return {};
-
-  try {
-    return JSON.parse(text);
-  } catch {
-    const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-    for (let i = lines.length - 1; i >= 0; i -= 1) {
-      if (!/^[{[]/.test(lines[i])) continue;
-      try {
-        return JSON.parse(lines.slice(i).join('\n'));
-      } catch {
-        // Keep looking for a JSON suffix.
-      }
-    }
-  }
-
-  return { text };
-}
-
-function asText(value) {
-  if (value == null) return '';
-  if (typeof value === 'string') return value;
-  if (value.success === true && value.data !== undefined) return asText(value.data);
-  if (typeof value.snapshot === 'string') return value.snapshot;
-  if (typeof value.text === 'string') return value.text;
-  if (typeof value.value === 'string') return value.value;
-  if (typeof value.result === 'string') return value.result;
-  if (typeof value.output === 'string') return value.output;
-  if (typeof value.url === 'string') return value.url;
-  if (typeof value.title === 'string') return value.title;
-  return JSON.stringify(value, null, 2);
-}
-
-function runAgentBrowser(commandArgs, options = {}) {
-  const session = safeId(options.session);
-  const json = options.json !== false;
-  const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS;
-  const bin = agentBrowserCommand();
-  const args = [...bin.prefix, ...baseArgs(session, json), ...commandArgs.map(String)];
-
-  return new Promise((resolve, reject) => {
-    const child = spawn(bin.command, args, {
-      cwd: process.cwd(),
-      env: {
-        ...process.env,
-        AGENT_BROWSER_SESSION: session,
-        AGENT_BROWSER_PROFILE: profileDir(session),
-      },
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-
-    let stdout = '';
-    let stderr = '';
-    const timer = setTimeout(() => {
-      child.kill('SIGTERM');
-      reject(new Error(`agent-browser timed out running: ${commandArgs.join(' ')}`));
-    }, timeoutMs);
-
-    child.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
-    child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
-    child.on('error', (err) => {
-      clearTimeout(timer);
-      reject(err.code === 'ENOENT'
-        ? new Error('agent-browser is not installed. Reinstall Amalgm or run `npm install agent-browser`.')
-        : err);
-    });
-    child.on('close', (code) => {
-      clearTimeout(timer);
-      if (code !== 0) {
-        reject(new Error((stderr || stdout || `agent-browser exited with code ${code}`).trim()));
-        return;
-      }
-      const result = json ? parseJson(stdout) : { text: stdout.trim() };
-      if (result && result.success === false) {
-        reject(new Error(result.error || result.message || 'agent-browser command failed'));
-        return;
-      }
-      resolve(result);
-    });
-  });
-}
-
-function directTarget(args = {}) {
-  if (args.ref) return String(args.ref);
-  if (args.selector) return String(args.selector);
-  return null;
-}
-
-function findCommand(args = {}, action, value) {
-  const command = ['find'];
-  if (args.text || args.name) command.push('text', args.text || args.name);
-  else if (args.label) command.push('label', args.label);
-  else if (args.placeholder) command.push('placeholder', args.placeholder);
-  else if (args.testId) command.push('testid', args.testId);
-  else if (args.role) command.push('role', args.role);
-  else throw new Error('A selector, ref, text, role, label, placeholder, or testId target is required');
-
-  command.push(action);
-  if (value !== undefined) command.push(value);
-  if (args.role && args.name) command.push('--name', args.name);
-  return command;
-}
-
-async function readTextCommand(command, session) {
-  return asText(await runAgentBrowser(command, { session, timeoutMs: 30_000 }));
-}
-
-async function stateBrowser(args = {}, context) {
-  const session = browserSession(args, context);
-  let url = '';
-  let title = '';
-
-  try { url = await readTextCommand(['get', 'url'], session); } catch {}
-  try { title = await readTextCommand(['get', 'title'], session); } catch {}
-
-  return tabInfo(session, { title, url, loading: false, visible: wantsHeaded() });
-}
-
-async function saveStateBrowser(args = {}, context) {
-  const session = browserSession(args, context);
-  const file = args.path || path.join(os.tmpdir(), `amalgm-browser-state-${session}-${Date.now()}-${crypto.randomUUID()}.json`);
-  await runAgentBrowser(['state', 'save', file], { session });
-  const state = JSON.parse(fs.readFileSync(file, 'utf8'));
-  if (!args.path) {
-    try { fs.rmSync(file, { force: true }); } catch {}
-  }
-  return tabInfo(session, {
-    state,
-    path: args.path ? file : undefined,
-    storageKinds: ['cookies', 'localStorage', 'sessionStorage'],
-  });
-}
-
-async function loadStateBrowser(args = {}, context) {
-  const session = browserSession(args, context);
-  let file = args.path;
-  let temporary = false;
-  if (!file) {
-    if (!args.state || typeof args.state !== 'object') throw new Error('state or path is required');
-    file = path.join(os.tmpdir(), `amalgm-browser-state-load-${session}-${Date.now()}-${crypto.randomUUID()}.json`);
-    fs.writeFileSync(file, `${JSON.stringify(args.state, null, 2)}\n`, { mode: 0o600 });
-    temporary = true;
-  }
-  await runAgentBrowser(['state', 'load', file], { session });
-  if (temporary) {
-    try { fs.rmSync(file, { force: true }); } catch {}
-  }
-  return tabInfo(session, {
-    loaded: true,
-    storageKinds: ['cookies', 'localStorage', 'sessionStorage'],
-  });
-}
-
-async function navigateBrowser(args = {}, context) {
-  const session = browserSession(args, context);
-  await runAgentBrowser(['open', args.url], { session });
-  const state = await stateBrowser(args, context);
-  return { ...state, status: 'ok' };
-}
-
-async function screenshotBrowser(args = {}, context) {
-  const session = browserSession(args, context);
-  const file = path.join(screenshotDir(), `${session}-${Date.now()}-${crypto.randomUUID()}.png`);
-  await runAgentBrowser(['screenshot', ...(args.fullPage ? ['--full'] : []), file], { session });
-  const buffer = fs.readFileSync(file);
-  return {
-    ...tabInfo(session),
-    base64: buffer.toString('base64'),
-    bytes: buffer.length,
-    mode: args.fullPage ? 'full page' : 'viewport',
-    path: file,
-  };
-}
-
-async function snapshotBrowser(args = {}, context) {
-  const session = browserSession(args, context);
-  const snapshot = await runAgentBrowser(['snapshot', '-i'], { session, timeoutMs: 30_000 });
-  const state = await stateBrowser(args, context);
-  return { ...state, snapshotText: asText(snapshot) };
-}
-
-async function clickBrowser(args = {}, context) {
-  const session = browserSession(args, context);
-  const target = directTarget(args);
-  await runAgentBrowser(target ? ['click', target] : findCommand(args, 'click'), { session });
-  return tabInfo(session, { description: `Clicked ${target || args.text || args.name || args.label || args.placeholder || args.testId || args.role}` });
-}
-
-async function typeBrowser(args = {}, context) {
-  const session = browserSession(args, context);
-  const target = directTarget(args);
-  const action = args.clear === false ? 'type' : 'fill';
-  await runAgentBrowser(target ? [action, target, args.text || ''] : findCommand(args, action, args.text || ''), { session });
-  return tabInfo(session, { description: `Typed into ${target || args.label || args.placeholder || args.role || 'target'}` });
-}
-
-async function pressBrowser(args = {}, context) {
-  const session = browserSession(args, context);
-  const target = directTarget(args);
-  if (target) await runAgentBrowser(['focus', target], { session });
-  await runAgentBrowser(['press', args.key], { session });
-  return tabInfo(session, { pressed: args.key });
-}
-
-async function getTextBrowser(args = {}, context) {
-  const session = browserSession(args, context);
-  const target = directTarget(args) || 'body';
-  return { ...tabInfo(session), text: await readTextCommand(['get', 'text', target], session) };
-}
-
-async function evaluateBrowser(args = {}, context) {
-  const session = browserSession(args, context);
-  return { ...tabInfo(session), result: await runAgentBrowser(['eval', args.script || ''], { session }) };
-}
-
-async function locatorCountBrowser(args = {}, context) {
-  const session = browserSession(args, context);
-  const target = directTarget(args);
-  if (!target) throw new Error('Count currently requires selector or ref. Use browser_snapshot for refs.');
-  const count = Number(await readTextCommand(['get', 'count', target], session));
-  return { ...tabInfo(session), count: Number.isFinite(count) ? count : 0 };
-}
-
-async function locatorTextBrowser(args = {}, context) {
-  const session = browserSession(args, context);
-  const target = directTarget(args);
-  if (!target) throw new Error('Text lookup currently requires selector or ref. Use browser_snapshot for refs.');
-  return { ...tabInfo(session), text: await readTextCommand(['get', 'text', target], session) };
-}
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function globToRegExp(pattern) {
-  const escaped = String(pattern)
-    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-    .replace(/\*\*/g, '.*')
-    .replace(/\*/g, '[^/]*');
-  return new RegExp(`^${escaped}$`);
-}
-
-function urlMatches(actual, expected) {
-  if (!expected) return true;
-  const target = String(expected);
-  if (actual === target) return true;
-  if (target.includes('*')) return globToRegExp(target).test(actual);
-  return actual.includes(target);
-}
-
-async function pollUntil(description, timeoutMs, check) {
-  const deadline = Date.now() + timeoutMs;
-  let lastError;
-
-  while (Date.now() < deadline) {
-    try {
-      if (await check()) return;
-    } catch (err) {
-      lastError = err;
-    }
-    await sleep(250);
-  }
-
-  throw new Error(`${description} timed out${lastError?.message ? `: ${lastError.message}` : ''}`);
-}
-
-async function waitForLoadStateBrowser(args = {}, context) {
-  const session = browserSession(args, context);
-  const state = args.state || 'load';
-  const timeoutMs = args.timeoutMs || 30_000;
-
-  if (state === 'networkidle') {
-    await runAgentBrowser(['wait', Math.min(timeoutMs, 1000)], { session, timeoutMs });
-    return stateBrowser(args, context);
-  }
-
-  await pollUntil(`wait for ${state}`, timeoutMs, async () => {
-    const readyState = await readTextCommand(['eval', 'document.readyState'], session);
-    return state === 'domcontentloaded'
-      ? readyState !== 'loading'
-      : readyState === 'complete';
-  });
-  return stateBrowser(args, context);
-}
-
-async function waitForURLBrowser(args = {}, context) {
-  const session = browserSession(args, context);
-  const expectedUrl = args.url;
-  await pollUntil(`wait for URL ${expectedUrl}`, args.timeoutMs || 30_000, async () => {
-    const currentUrl = await readTextCommand(['get', 'url'], session);
-    return urlMatches(currentUrl, expectedUrl);
-  });
-  return stateBrowser(args, context);
-}
-
-async function waitForSelectorBrowser(args = {}, context) {
-  const session = browserSession(args, context);
-  await runAgentBrowser(['wait', args.selector], { session, timeoutMs: args.timeoutMs || 30_000 });
-  return { ...tabInfo(session), selector: args.selector, matched: true };
-}
-
-async function tabNavigationBrowser(action, args = {}, context) {
-  const session = browserSession(args, context);
-  await runAgentBrowser([action], { session });
-  return stateBrowser(args, context);
-}
-
-async function tabsListBrowser() {
-  return {
-    tabs: Array.from(knownSessions.values()).sort((a, b) => (b.lastActiveAt || 0) - (a.lastActiveAt || 0)),
-    backend: 'agent-browser',
-  };
-}
-
-async function tabsSelectedBrowser(context) {
-  return stateBrowser({}, context);
-}
-
-async function tabsNewBrowser(args = {}, context) {
-  const session = safeId(args.browserSessionId || args.sessionId || `browser-${Date.now().toString(36)}`);
-  if (args.url) await navigateBrowser({ ...args, browserSessionId: session }, context);
-  return stateBrowser({ ...args, browserSessionId: session }, context);
-}
-
-async function tabsGetBrowser(args = {}, context) {
-  return stateBrowser(args, context);
-}
-
-async function tabsSelectBrowser(args = {}, context) {
-  return stateBrowser(args, context);
-}
-
-async function cuaBrowser(action, args = {}, context) {
-  const session = browserSession(args, context);
-  const x = Math.round(Number(args.x || 0));
-  const y = Math.round(Number(args.y || 0));
-  if (action === 'cua_move') await runAgentBrowser(['mouse', 'move', x, y], { session });
-  if (action === 'cua_click') {
-    await runAgentBrowser(['mouse', 'move', x, y], { session });
-    await runAgentBrowser(['mouse', 'down', args.button || 1], { session });
-    await runAgentBrowser(['mouse', 'up', args.button || 1], { session });
-  }
-  if (action === 'cua_double_click') {
-    await runAgentBrowser(['mouse', 'move', x, y], { session });
-    await runAgentBrowser(['mouse', 'down', 1], { session });
-    await runAgentBrowser(['mouse', 'up', 1], { session });
-    await runAgentBrowser(['mouse', 'down', 1], { session });
-    await runAgentBrowser(['mouse', 'up', 1], { session });
-  }
-  if (action === 'cua_scroll') await runAgentBrowser(['mouse', 'wheel', args.scrollY || 0, args.scrollX || 0], { session });
-  if (action === 'cua_type') await runAgentBrowser(['keyboard', 'type', args.text || ''], { session });
-  if (action === 'cua_keypress') await runAgentBrowser(['press', (args.keys || []).join('+')], { session });
-  if (action === 'cua_drag') await dragBrowser(args, session);
-  return tabInfo(session, { ok: true });
-}
-
-async function dragBrowser(args, session) {
-  const pathPoints = Array.isArray(args.path) ? args.path : [];
-  if (pathPoints.length < 2) throw new Error('drag path must contain at least two points');
-  await runAgentBrowser(['mouse', 'move', pathPoints[0].x, pathPoints[0].y], { session });
-  await runAgentBrowser(['mouse', 'down', 1], { session });
-  for (const point of pathPoints.slice(1)) {
-    await runAgentBrowser(['mouse', 'move', point.x, point.y], { session });
-  }
-  await runAgentBrowser(['mouse', 'up', 1], { session });
-}
-
-async function clipboardBrowser(action, args = {}, context) {
-  const session = browserSession(args, context);
-  if (action === 'clipboard_read_text') {
-    return { ...tabInfo(session), text: await readTextCommand(['clipboard', 'read'], session) };
-  }
-  await runAgentBrowser(['clipboard', 'write', args.text || ''], { session });
-  return tabInfo(session, { written: true });
-}
-
-async function startVideoBrowser(args = {}, context) {
-  const session = browserSession(args, context);
-  const id = safeId(args.sessionId || args.recording_id || session, session);
-  const file = path.join(recordingDir(id), `${new Date().toISOString().replace(/[:.]/g, '-')}.webm`);
-  await runAgentBrowser(['record', 'start', file], { session });
-  activeRecordings.set(session, file);
-  return tabInfo(session, { path: file, mimeType: 'video/webm' });
-}
-
-async function stopVideoBrowser(args = {}, context) {
-  const session = browserSession(args, context);
-  await runAgentBrowser(['record', 'stop'], { session });
-  const file = activeRecordings.get(session);
-  activeRecordings.delete(session);
-  if (!file) return tabInfo(session, { stopped: true });
-  const bytes = fs.existsSync(file) ? fs.statSync(file).size : 0;
-  return tabInfo(session, {
-    path: file,
-    relativePath: path.relative(amalgmDir(), file),
-    url: `/api/browser-sessions/video?file=${encodeURIComponent(path.relative(amalgmDir(), file))}`,
-    bytes,
-    mimeType: 'video/webm',
-  });
-}
-
-async function closeBrowser(args = {}, context) {
-  const session = browserSession(args, context);
-  await runAgentBrowser(['close'], { session });
-  knownSessions.delete(session);
-}
-
-module.exports = {
-  clipboardBrowser,
-  closeBrowser,
-  clickBrowser,
-  cuaBrowser,
-  evaluateBrowser,
-  getTextBrowser,
-  locatorCountBrowser,
-  locatorTextBrowser,
-  loadStateBrowser,
-  navigateBrowser,
-  pressBrowser,
-  screenshotBrowser,
-  saveStateBrowser,
-  snapshotBrowser,
-  startVideoBrowser,
-  stateBrowser,
-  stopVideoBrowser,
-  tabNavigationBrowser,
-  tabsGetBrowser,
-  tabsListBrowser,
-  tabsNewBrowser,
-  tabsSelectBrowser,
-  tabsSelectedBrowser,
-  typeBrowser,
-  waitForLoadStateBrowser,
-  waitForSelectorBrowser,
-  waitForURLBrowser,
-  _private: {
-    browserRoot,
-    browserSession,
-    profileDir,
-    runAgentBrowser,
-    safeId,
-  },
-};

package/runtime/scripts/amalgm-mcp/browser/page.js

@@ -1,25 +0,0 @@
-const electron = require('./electron-bridge');
-const agentBrowser = require('./agent-browser');
-
-function isPackagedDesktopRuntime() {
-  const execPath = process.execPath || '';
-  return process.env.ELECTRON_RUN_AS_NODE === '1' && execPath.includes('.app/Contents/MacOS/');
-}
-
-function backend() {
-  const requested = (process.env.AMALGM_BROWSER_BACKEND || '').toLowerCase();
-  if (requested === 'agent-browser' || requested === 'external') return agentBrowser;
-  if (requested === 'electron') return electron;
-
-  // In the desktop app this bridge drives the visible in-tab Electron webview.
-  // Outside Electron, keep the agent-browser CLI fallback for headless/remote use.
-  if (electron.isConfigured() || isPackagedDesktopRuntime()) return electron;
-  return agentBrowser;
-}
-
-const exported = {};
-for (const key of Object.keys(agentBrowser)) {
-  exported[key] = (...args) => backend()[key](...args);
-}
-
-module.exports = exported;