amalgm 0.1.154 → 0.1.155

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

@@ -7,7 +7,7 @@
  *   backend.js  — which browser: visible desktop surface vs headless cli
  *   attach.js   — the visible-surface handshake + command transport
  *   capture.js  — pixels: screenshots, and the recorder's frame source
- *   sessions.js — session identity, 1:1 with durable profiles
+ *   sessions.js — live session identity; saved profile registration is explicit
  *   cli.js      — the agent-browser process wrapper
  *
  * This module stays the single import for tool handlers and tests; the
@@ -21,12 +21,18 @@ const attach = require('./attach');
 const capture = require('./capture');
 const sessions = require('./sessions');
 const typing = require('./typing');
-const { COOKIE_SOURCE_BUNDLE_ID, cookieSourceVersion } = require('./cookie-source');
-const { getBrowserAuthBundle, readEncryptedStateBundle } = require('./auth-bundles');
+const {
+  cookieJarState,
+  diffCookieSnapshots,
+  mergeCookieJar,
+  normalizeCookieList,
+  readCookieJar,
+} = require('./cookie-jar');
 
 const { backendFor, sessionFor, sessionInfo } = sessions;
 const { run, runBatch, readText } = attach;
 const loadedCookieSources = new Map();
+const headlessCookieBaselines = new Map();
 
 /**
  * Target grammar shared by click/fill:
@@ -79,29 +85,83 @@ async function loadStateIntoSession(session, statePayload, context) {
 
 async function ensureCookieSourceLoaded(session, context) {
   if (cookieSourceDisabled()) return;
-  // Attached sessions drive the desktop app's own jar — the jar the cookie
-  // source is exported FROM (electron/browserCookieSource.ts). Importing the
-  // bundle back into it is at best an echo and at worst overwrites the user's
-  // live cookies with older ones. Only headless sessions import.
+  // Attached sessions synchronize through Electron's cookie-jar adapter.
+  // This adapter owns only standalone agent-browser sessions.
   if (sessions.backendFor(session) === 'attached') return;
-  const bundle = getBrowserAuthBundle(COOKIE_SOURCE_BUNDLE_ID);
-  if (!bundle?.blobPath) return;
-  const version = cookieSourceVersion(bundle);
-  if (version && loadedCookieSources.get(session) === version) return;
   try {
-    const { payload } = readEncryptedStateBundle(COOKIE_SOURCE_BUNDLE_ID);
-    if (payload?.state && typeof payload.state === 'object') {
-      await loadStateIntoSession(session, payload.state, context);
-      console.error(`[browser] cookie source ${String(version).slice(0, 12)} imported into session ${session}`);
+    let jar = readCookieJar();
+    if (loadedCookieSources.get(session) === jar.versionToken) return;
+
+    if (!jar.exists) {
+      // First adapter wins only when the canonical jar has never existed.
+      // This migrates a deliberately reused headless profile without making
+      // an empty new profile authoritative over other adapters.
+      const localCookies = await readHeadlessCookies(session, context);
+      if (localCookies.length) {
+        jar = mergeCookieJar({ sourceId: `headless:${session}:seed`, upserts: localCookies });
+      }
+      loadedCookieSources.set(session, jar.versionToken);
+      headlessCookieBaselines.set(session, { versionToken: jar.versionToken, cookies: localCookies });
+      return;
     }
+
+    // State loading adds/overwrites cookies but does not reliably remove
+    // cookies absent from the snapshot. Clear first so tombstones and logout
+    // mutations converge too. Headless profiles contain no app UI session.
+    await run(session, ['cookies', 'clear'], { context });
+    await loadStateIntoSession(session, cookieJarState(jar), context);
+    const cookies = normalizeCookieList(jar.cookies);
+    loadedCookieSources.set(session, jar.versionToken);
+    headlessCookieBaselines.set(session, { versionToken: jar.versionToken, cookies });
+    console.error(`[browser] cookie jar ${jar.versionToken.slice(0, 18)} applied to session ${session}`);
   } catch (err) {
-    // A bad bundle (key mismatch, corrupt blob, load failure) must degrade to
-    // a logged-out session, never break every browser verb.
-    console.error(`[browser] cookie source import failed for session ${session}: ${err.message}`);
+    // A corrupt jar or adapter failure must not break every browser verb.
+    console.error(`[browser] cookie jar apply failed for session ${session}: ${err.message}`);
   }
-  // Recorded even on failure: the failure is a property of this bundle
-  // version, so retrying on every verb would only repeat the error.
-  if (version) loadedCookieSources.set(session, version);
+}
+
+function cookieResultList(result) {
+  const data = result?.data ?? result;
+  return normalizeCookieList(data?.cookies || []);
+}
+
+async function readHeadlessCookies(session, context) {
+  return cookieResultList(await run(session, ['cookies'], { context }));
+}
+
+async function syncHeadlessCookies(session, context) {
+  if (cookieSourceDisabled() || sessions.backendFor(session) === 'attached') return;
+  const baseline = headlessCookieBaselines.get(session);
+  if (!baseline) return;
+  try {
+    const cookies = await readHeadlessCookies(session, context);
+    const mutations = diffCookieSnapshots(baseline.cookies, cookies);
+    if (!mutations.upserts.length && !mutations.deletes.length) return;
+
+    // If another adapter changed the jar while this browser action was in
+    // flight, merge only this session's actual diff and deliberately leave
+    // its loaded token stale. The next verb will apply the combined snapshot.
+    const beforeMerge = readCookieJar();
+    const jar = mergeCookieJar({
+      sourceId: `headless:${session}`,
+      upserts: mutations.upserts,
+      deletes: mutations.deletes,
+    });
+    const converged = beforeMerge.versionToken === baseline.versionToken;
+    const versionToken = converged ? jar.versionToken : baseline.versionToken;
+    headlessCookieBaselines.set(session, { versionToken, cookies });
+    loadedCookieSources.set(session, versionToken);
+    console.error(`[browser] cookie jar accepted ${mutations.upserts.length} upsert(s), ${mutations.deletes.length} deletion(s) from session ${session}`);
+  } catch (err) {
+    // Cookie write-back is best-effort per verb; the browser action itself is
+    // still truthful and the next verb retries from the last good baseline.
+    console.error(`[browser] cookie jar write-back failed for session ${session}: ${err.message}`);
+  }
+}
+
+async function finishCookieAction(session, result, context) {
+  await syncHeadlessCookies(session, context);
+  return result;
 }
 
 async function state(args = {}, context) {
@@ -109,31 +169,31 @@ async function state(args = {}, context) {
   await ensureCookieSourceLoaded(session, context);
   let current = { url: '', title: '' };
   try { current = parseState(await run(session, STATE_COMMAND, { context })); } catch {}
-  return sessionInfo(session, current);
+  return finishCookieAction(session, sessionInfo(session, current), context);
 }
 
 async function open(args = {}, context) {
   const session = sessionFor(args, context);
   await ensureCookieSourceLoaded(session, context);
   const entries = await runBatch(session, [['open', args.url], STATE_COMMAND], { context });
-  return sessionInfo(session, parseState(entries[1]));
+  return finishCookieAction(session, sessionInfo(session, parseState(entries[1])), context);
 }
 
 async function snapshot(args = {}, context) {
   const session = sessionFor(args, context);
   await ensureCookieSourceLoaded(session, context);
   const entries = await runBatch(session, [['snapshot', '-i'], STATE_COMMAND], { timeoutMs: 30_000, context });
-  return {
+  return finishCookieAction(session, {
     ...sessionInfo(session, parseState(entries[1])),
     snapshotText: cli.asText(entries[0]?.result ?? entries[0]),
-  };
+  }, context);
 }
 
 async function screenshot(args = {}, context) {
   const session = sessionFor(args, context);
   await ensureCookieSourceLoaded(session, context);
   const shot = await capture.screenshot(session, args, context);
-  return { ...sessionInfo(session), ...shot };
+  return finishCookieAction(session, { ...sessionInfo(session), ...shot }, context);
 }
 
 async function click(args = {}, context) {
@@ -143,7 +203,7 @@ async function click(args = {}, context) {
   await run(session, target.startsWith('text=')
     ? findArgs(target, 'click')
     : ['click', target], { context });
-  return sessionInfo(session, { clicked: target });
+  return finishCookieAction(session, sessionInfo(session, { clicked: target }), context);
 }
 
 async function fill(args = {}, context) {
@@ -168,7 +228,7 @@ async function fill(args = {}, context) {
       await run(session, fillCommand, { context });
     }
   }
-  return sessionInfo(session, { filled: target, submitted: Boolean(args.submit) });
+  return finishCookieAction(session, sessionInfo(session, { filled: target, submitted: Boolean(args.submit) }), context);
 }
 
 async function press(args = {}, context) {
@@ -179,7 +239,7 @@ async function press(args = {}, context) {
   } else {
     await run(session, ['press', args.key], { context });
   }
-  return sessionInfo(session, { pressed: args.key });
+  return finishCookieAction(session, sessionInfo(session, { pressed: args.key }), context);
 }
 
 /**
@@ -191,7 +251,7 @@ async function select(args = {}, context) {
   const session = sessionFor(args, context);
   await ensureCookieSourceLoaded(session, context);
   await run(session, ['select', String(args.target || ''), String(args.value ?? '')], { context });
-  return sessionInfo(session, { selected: args.target, value: args.value });
+  return finishCookieAction(session, sessionInfo(session, { selected: args.target, value: args.value }), context);
 }
 
 async function evaluate(args = {}, context) {
@@ -211,7 +271,7 @@ async function evaluate(args = {}, context) {
   const data = result?.data ?? result;
   // agent-browser wraps eval results as { origin, result }.
   const value = data && typeof data === 'object' && 'result' in data ? data.result : data;
-  return { ...sessionInfo(session), result: value };
+  return finishCookieAction(session, { ...sessionInfo(session), result: value }, context);
 }
 
 async function wait(args = {}, context) {
@@ -221,20 +281,22 @@ async function wait(args = {}, context) {
 
   if (args.ms) {
     await new Promise((resolve) => setTimeout(resolve, Math.min(Number(args.ms) || 0, 60_000)));
-    return sessionInfo(session, { waited: `${args.ms}ms` });
+    return finishCookieAction(session, sessionInfo(session, { waited: `${args.ms}ms` }), context);
   }
   if (args.url) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
       const current = await readText(session, ['get', 'url']);
-      if (current.includes(args.url.replace(/\*/g, ''))) return sessionInfo(session, { matched: current });
+      if (current.includes(args.url.replace(/\*/g, ''))) {
+        return finishCookieAction(session, sessionInfo(session, { matched: current }), context);
+      }
       await new Promise((resolve) => setTimeout(resolve, 250));
     }
     throw new Error(`Timed out waiting for URL ${args.url}`);
   }
   if (args.selector) {
     await run(session, ['wait', args.selector], { timeoutMs, context });
-    return sessionInfo(session, { matched: args.selector });
+    return finishCookieAction(session, sessionInfo(session, { matched: args.selector }), context);
   }
   throw new Error('wait requires one of: selector, url, ms');
 }
@@ -261,15 +323,15 @@ async function passthrough(args = {}, context) {
   if (attached && commandArgs[0] === 'keyboard' && commandArgs[1] === 'type') {
     const text = commandArgs.slice(2).join(' ');
     const result = await run(session, ['eval', typing.insertTextScript(text)], { timeoutMs: args.timeoutMs || 60_000, context });
-    return { ...sessionInfo(session), result: result?.data ?? result };
+    return finishCookieAction(session, { ...sessionInfo(session), result: result?.data ?? result }, context);
   }
   if (attached && commandArgs[0] === 'press') {
     const key = commandArgs.slice(1).join('+');
     const result = await run(session, ['eval', typing.keyScript(key)], { timeoutMs: args.timeoutMs || 60_000, context });
-    return { ...sessionInfo(session), result: result?.data ?? result };
+    return finishCookieAction(session, { ...sessionInfo(session), result: result?.data ?? result }, context);
   }
   const result = await run(session, commandArgs, { timeoutMs: args.timeoutMs || 60_000, context });
-  return { ...sessionInfo(session), result: result?.data ?? result };
+  return finishCookieAction(session, { ...sessionInfo(session), result: result?.data ?? result }, context);
 }
 
 /** Schema convention is 1 left / 2 middle / 3 right; agent-browser's mouse
@@ -347,7 +409,7 @@ async function cua(action, args = {}, context) {
       ['mouse', 'up', 'left'],
     ], options);
   }
-  return sessionInfo(session, { ok: true });
+  return finishCookieAction(session, sessionInfo(session, { ok: true }), context);
 }
 
 // ---------------------------------------------------------------------------
@@ -356,6 +418,7 @@ async function cua(action, args = {}, context) {
 
 async function saveState(args = {}, context) {
   const session = sessionFor(args, context);
+  await ensureCookieSourceLoaded(session, context);
   const fs = require('fs');
   const os = require('os');
   const path = require('path');
@@ -368,28 +431,31 @@ async function saveState(args = {}, context) {
   }
   let current = { url: '', title: '' };
   try { current = parseState(await run(session, STATE_COMMAND, { context })); } catch {}
-  return {
+  return finishCookieAction(session, {
     ...sessionInfo(session, current),
     state: stateData,
     path: args.path ? file : undefined,
     storageKinds: ['cookies', 'localStorage', 'sessionStorage'],
-  };
+  }, context);
 }
 
 async function loadState(args = {}, context) {
   const session = sessionFor(args, context);
+  await ensureCookieSourceLoaded(session, context);
   let file = args.path;
   if (!file) {
     if (!args.state || typeof args.state !== 'object') throw new Error('state or path is required');
     await loadStateIntoSession(session, args.state, context);
-    return sessionInfo(session, { loaded: true, storageKinds: ['cookies', 'localStorage', 'sessionStorage'] });
+    return finishCookieAction(session, sessionInfo(session, { loaded: true, storageKinds: ['cookies', 'localStorage', 'sessionStorage'] }), context);
   }
   await run(session, ['state', 'load', file], { context });
-  return sessionInfo(session, { loaded: true, storageKinds: ['cookies', 'localStorage', 'sessionStorage'] });
+  return finishCookieAction(session, sessionInfo(session, { loaded: true, storageKinds: ['cookies', 'localStorage', 'sessionStorage'] }), context);
 }
 
 async function close(args = {}, context) {
   const session = sessionFor(args, context);
+  const attached = sessions.backendFor(session) === 'attached';
+  await syncHeadlessCookies(session, context);
   // A recording keeps a CDP connection and an encoder alive — closing the
   // session finalizes it (saving what was captured) rather than orphaning it.
   const recorder = require('./recorder');
@@ -413,6 +479,17 @@ async function close(args = {}, context) {
   }
   attach.detach(session);
   sessions.knownSessions.delete(session);
+  sessions.homes.delete(session);
+  loadedCookieSources.delete(session);
+  headlessCookieBaselines.delete(session);
+  if (!attached) {
+    try {
+      require('./profiles').deleteBrowserProfile(session, {
+        onlyIfUnreferenced: true,
+        source: 'browser-session-close',
+      });
+    } catch {}
+  }
 }
 
 module.exports = {
@@ -424,6 +501,7 @@ module.exports = {
   // Session façade (sessions.js).
   backendFor: sessions.backendFor,
   ensureCookieSourceLoaded,
+  syncHeadlessCookies,
   knownSessions: sessions.knownSessions,
   sessionFor,
   sessionInfo,

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

@@ -142,11 +142,135 @@ function touchBrowserProfile(input = {}, options = {}) {
   }, options);
 }
 
+function referencedProfileIds(database = openLocalDb()) {
+  const ids = new Set();
+  for (const row of database.prepare('SELECT DISTINCT profile_id FROM browser_auth_bundles').all()) {
+    if (row.profile_id) ids.add(safeId(row.profile_id));
+  }
+  for (const row of database.prepare(`
+    SELECT DISTINCT profile_id FROM browser_login_sessions
+    WHERE status IN ('pending', 'active')
+  `).all()) {
+    if (row.profile_id) ids.add(safeId(row.profile_id));
+  }
+  return ids;
+}
+
+function isBrowserProfileDurable(id, database = openLocalDb()) {
+  const profileId = safeId(id);
+  if (referencedProfileIds(database).has(profileId)) return true;
+  const row = database.prepare('SELECT source FROM browser_profiles WHERE id = ?').get(profileId);
+  return Boolean(row && !['agent-browser', 'agent-browser-ephemeral'].includes(row.source));
+}
+
+function removeProfileDirectory(profileId) {
+  const target = profilePathFor(profileId);
+  const root = path.dirname(profilePathFor('__profile_root_marker__'));
+  if (path.dirname(target) !== root) throw new Error(`Unsafe browser profile path: ${target}`);
+  fs.rmSync(target, { recursive: true, force: true });
+}
+
+function deleteBrowserProfile(id, options = {}) {
+  const db = openLocalDb();
+  const profileId = safeId(id);
+  if (options.onlyIfUnreferenced !== false && isBrowserProfileDurable(profileId, db)) {
+    return { ok: true, deleted: false, preserved: true, id: profileId };
+  }
+  if (options.deleteDirectory !== false) removeProfileDirectory(profileId);
+  const result = db.prepare('DELETE FROM browser_profiles WHERE id = ?').run(profileId);
+  if (result.changes) publishProfiles(db, options.source || 'browser-profile-delete');
+  return { ok: true, deleted: Boolean(result.changes), directoryDeleted: options.deleteDirectory !== false, id: profileId };
+}
+
+function profileLastTouchedAt(profilePath) {
+  const candidates = [
+    profilePath,
+    path.join(profilePath, 'Local State'),
+    path.join(profilePath, 'Default'),
+    path.join(profilePath, 'Default', 'Cookies'),
+    path.join(profilePath, 'Default', 'Network', 'Cookies'),
+    path.join(profilePath, 'Default', 'History'),
+  ];
+  let latest = 0;
+  for (const candidate of candidates) {
+    try { latest = Math.max(latest, fs.statSync(candidate).mtimeMs); } catch {}
+  }
+  return latest;
+}
+
+function hasLiveProfileLock(profilePath) {
+  const lock = path.join(profilePath, 'SingletonLock');
+  try {
+    const stat = fs.lstatSync(lock);
+    if (stat.isSymbolicLink()) {
+      const target = fs.readlinkSync(lock);
+      const pid = Number(target.match(/-(\d+)$/)?.[1] || 0);
+      if (!pid) return false;
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    // Some Chromium builds use a regular lock file. Treat only a recently
+    // touched one as live; an ancient crash artifact must not defeat GC.
+    return Date.now() - stat.mtimeMs < 5 * 60 * 1000;
+  } catch {
+    return false;
+  }
+}
+
+function pruneEphemeralBrowserProfiles(options = {}) {
+  const db = openLocalDb();
+  const root = path.dirname(profilePathFor('__profile_root_marker__'));
+  const ttlHours = Number(options.ttlHours ?? process.env.AMALGM_BROWSER_PROFILE_TTL_HOURS ?? 24);
+  if (!Number.isFinite(ttlHours) || ttlHours < 0) return { removedDirectories: 0, removedRows: 0 };
+  const cutoff = Date.now() - ttlHours * 60 * 60 * 1000;
+  const durable = referencedProfileIds(db);
+  for (const row of db.prepare('SELECT id, source FROM browser_profiles').all()) {
+    if (!['agent-browser', 'agent-browser-ephemeral'].includes(row.source)) durable.add(safeId(row.id));
+  }
+
+  let removedDirectories = 0;
+  const removedIds = [];
+  let entries = [];
+  try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch {}
+  for (const entry of entries) {
+    if (!(entry.isDirectory() || entry.isSymbolicLink())) continue;
+    const id = safeId(entry.name);
+    const target = path.join(root, entry.name);
+    if (durable.has(id) || hasLiveProfileLock(target) || profileLastTouchedAt(target) > cutoff) continue;
+    removeProfileDirectory(id);
+    removedDirectories += 1;
+    removedIds.push(id);
+  }
+
+  let removedRows = 0;
+  const ephemeralRows = db.prepare(`
+    SELECT id FROM browser_profiles
+    WHERE source IN ('agent-browser', 'agent-browser-ephemeral')
+  `).all();
+  for (const row of ephemeralRows) {
+    const id = safeId(row.id);
+    if (durable.has(id)) continue;
+    const target = profilePathFor(id);
+    if (hasLiveProfileLock(target) || profileLastTouchedAt(target) > cutoff) continue;
+    removedRows += db.prepare('DELETE FROM browser_profiles WHERE id = ?').run(id).changes;
+  }
+  if (removedRows) publishProfiles(db, options.source || 'browser-profile-prune');
+  return { removedDirectories, removedRows, removedIds };
+}
+
 module.exports = {
   PROFILE_RESOURCE,
+  deleteBrowserProfile,
   getBrowserProfile,
+  isBrowserProfileDurable,
   listBrowserProfiles,
   normalizeProfile,
+  pruneEphemeralBrowserProfiles,
+  referencedProfileIds,
   touchBrowserProfile,
   upsertBrowserProfile,
 };

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

@@ -12,11 +12,14 @@ const {
   completeBrowserLoginSession,
   createBrowserLoginSession,
   deleteBrowserAuthBundle,
+  getBrowserAuthBundle,
   listBrowserLoginSessions,
   listBrowserAuthBundles,
   listBrowserProfiles,
   markBrowserLoginSessionActive,
   markBrowserAuthBundleImported,
+  mergeCookieJar,
+  readCookieJar,
   readEncryptedStateBundle,
   safeId,
   touchBrowserProfile,
@@ -66,13 +69,31 @@ async function exportAuthBundleFromProfile(body = {}) {
       browserSessionId: profileId,
     }, {});
 
-  const bundle = writeEncryptedStateBundle({
-    id: body.id || (profileId === DEFAULT_COOKIE_SOURCE_PROFILE_ID ? COOKIE_SOURCE_BUNDLE_ID : undefined),
-    name: body.name || (profileId === DEFAULT_COOKIE_SOURCE_PROFILE_ID ? 'Browser cookie source' : saved.title || profileId),
-    profileId,
-    domains: Array.isArray(body.domains) ? body.domains : [],
-    state: saved.state || {},
-  });
+  const requestedId = body.id || (profileId === DEFAULT_COOKIE_SOURCE_PROFILE_ID ? COOKIE_SOURCE_BUNDLE_ID : undefined);
+  const isLegacyCookieJarPush = requestedId === COOKIE_SOURCE_BUNDLE_ID
+    && body.state
+    && typeof body.state === 'object';
+  let bundle;
+  if (isLegacyCookieJarPush) {
+    // Rolling-upgrade compatibility for older Electron clients. Merge their
+    // snapshot into the canonical jar instead of replacing it, so cookies
+    // written by headless/future adapters cannot be clobbered by an old
+    // one-way producer. New adapters use /browser/cookie-jar mutations.
+    mergeCookieJar({
+      sourceId: body.sourceId || 'legacy-electron-snapshot',
+      upserts: saved.state?.cookies || [],
+      excludeHosts: body.excludeHosts,
+    });
+    bundle = getBrowserAuthBundle(COOKIE_SOURCE_BUNDLE_ID);
+  } else {
+    bundle = writeEncryptedStateBundle({
+      id: requestedId,
+      name: body.name || (profileId === DEFAULT_COOKIE_SOURCE_PROFILE_ID ? 'Browser cookie source' : saved.title || profileId),
+      profileId,
+      domains: Array.isArray(body.domains) ? body.domains : [],
+      state: saved.state || {},
+    });
+  }
 
   touchBrowserProfile({
     id: profileId,
@@ -83,6 +104,23 @@ async function exportAuthBundleFromProfile(body = {}) {
   return { bundle, saved, profileId };
 }
 
+function handleCookieJarGet(sendJson) {
+  // Internal authenticated runtime endpoint. Cookie values never enter tool
+  // output, resource snapshots, state events, or logs; browser adapters need
+  // them here to apply the canonical jar to their local implementation.
+  sendJson(200, { jar: readCookieJar() });
+}
+
+function handleCookieJarMerge(body = {}, sendJson) {
+  const jar = mergeCookieJar({
+    sourceId: body.sourceId,
+    upserts: body.upserts,
+    deletes: body.deletes,
+    excludeHosts: body.excludeHosts,
+  });
+  sendJson(200, { jar });
+}
+
 async function handleAuthBundleExport(body = {}, sendJson) {
   const result = await exportAuthBundleFromProfile(body);
   sendJson(200, { bundle: result.bundle });
@@ -293,6 +331,8 @@ module.exports = {
   handleAuthBundleExport,
   handleAuthBundleImport,
   handleAuthBundlesList,
+  handleCookieJarGet,
+  handleCookieJarMerge,
   handleLoginSessionCancel,
   handleLoginSessionComplete,
   handleLoginSessionCreate,

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

@@ -3,10 +3,11 @@
 /**
  * Browser session identity and registry.
  *
- * A session is 1:1 with a durable profile directory; the default session id
- * is the caller's chat session, so one conversation keeps one browser across
- * tool calls without anyone passing ids around. Parallel sessions stay
- * isolated because each gets its own agent-browser daemon and profile.
+ * The default session id is the caller's chat session, so one conversation
+ * keeps one live browser across tool calls without anyone passing ids around.
+ * Parallel sessions stay isolated because each gets its own agent-browser
+ * daemon and working profile. A working profile becomes durable only when an
+ * auth bundle/login/manual record explicitly references it.
  */
 
 const cli = require('./cli');
@@ -55,17 +56,19 @@ function sessionFor(args = {}, context = {}) {
 
 function rememberProfile(session) {
   try {
-    require('./profiles').touchBrowserProfile({
+    const profiles = require('./profiles');
+    if (!profiles.isBrowserProfileDurable(session)) return;
+    profiles.touchBrowserProfile({
       id: session,
       name: session,
-      source: 'agent-browser',
+      source: 'agent-browser-ephemeral',
       profilePath: cli.profileDir(session),
     }, { source: 'agent-browser' });
   } catch {}
 }
 
 function sessionInfo(session, extra = {}) {
-  rememberProfile(session);
+  if (!knownSessions.has(session)) rememberProfile(session);
   const info = {
     session,
     browserSessionId: session,

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

@@ -3,6 +3,7 @@
 module.exports = {
   ...require('./paths'),
   ...require('./profiles'),
+  ...require('./cookie-jar'),
   ...require('./auth-bundles'),
   ...require('./login-sessions'),
 };

package/runtime/scripts/amalgm-mcp/index.js

@@ -95,6 +95,19 @@ async function boot() {
   // look alive first and warm up second.
   await listen();
 
+  // Ordinary chat browsers are working directories, not saved identities.
+  // Explicit auth/login profiles are preserved; closed sessions are removed
+  // immediately and crash leftovers age out here without touching live locks.
+  try {
+    const { pruneEphemeralBrowserProfiles } = require('./browser/profiles');
+    const pruned = pruneEphemeralBrowserProfiles({ source: 'runtime-startup' });
+    if (pruned.removedDirectories || pruned.removedRows) {
+      console.log(`[AmalgmMCP] Pruned ${pruned.removedDirectories} ephemeral browser profile(s) and ${pruned.removedRows} stale registry row(s)`);
+    }
+  } catch (err) {
+    console.warn(`[AmalgmMCP] Browser profile pruning skipped: ${err.message}`);
+  }
+
   await ensureProxyToken();
 
   const { ensureAutomationsStore } = require('./automations/store');

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

@@ -3,6 +3,16 @@
 const browserRest = require('../../browser/rest');
 
 async function handleBrowserRoutes(ctx) {
+  if (ctx.pathname === '/browser/cookie-jar' && ctx.method === 'GET') {
+    ctx.res.setHeader('Cache-Control', 'no-store');
+    browserRest.handleCookieJarGet(ctx.sendJson);
+    return true;
+  }
+  if (ctx.pathname === '/browser/cookie-jar/merge' && ctx.method === 'POST') {
+    ctx.res.setHeader('Cache-Control', 'no-store');
+    browserRest.handleCookieJarMerge(await ctx.readJsonBody(), ctx.sendJson);
+    return true;
+  }
   if (ctx.pathname === '/browser/profiles' && ctx.method === 'GET') {
     browserRest.handleProfilesList(ctx.sendJson);
     return true;