@moretea-labs/forge 1.8.1 → 1.8.2

package/src/runtime/plugins/browser-adapter.ts

@@ -5,6 +5,7 @@ import { createServer as createNetServer } from 'net';
 import { existsSync, mkdirSync, readFileSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'path';
+import { fileURLToPath } from 'url';
 import type {
   AssistantPluginActionExecutionInput,
   AssistantPluginAuthorizationContext,
@@ -22,7 +23,6 @@ import {
   browserPermissions,
 } from './browser-manifest-surface';
 import { executeBrowserActionThroughNode, shouldUseBrowserNodeBridge } from './browser-node-bridge';
-import { BrowserProviderUnavailableBeforeActionError } from '../../../packages/plugin-runtime/browser/provider-registry';
 import { MAX_BROWSER_CDP_ENDPOINT_CANDIDATES } from '../../../packages/plugin-runtime/browser/runtime-contract';
 import {
   ALL_BROWSER_PROVIDER_CAPABILITIES,
@@ -33,6 +33,8 @@ import {
   invalidateBrowserRuntime,
 } from './browser-runtime';
 import { activateRuntimeComputerBrowserApplication } from '../root/computer-composition';
+import { resolveWorkspaceTargetPath, WorkspaceTargetGrantError } from '../workspace-targets';
+import { pluginCapabilityAuthorizationOwnerScope } from './capability-authorization-grants';
 import {
   DEFAULT_BROWSER_SESSION_LIST_LIMIT,
   MAX_BROWSER_SESSION_LIST_LIMIT,
@@ -55,6 +57,7 @@ import {
   readMacOsBrowserOwnedTabMetadata,
   macOsActiveBrowserAttachSupported,
   macOsBrowserJavaScriptAutomationDisabled,
+  assertMacOsBrowserApplicationRunning,
   type MacOsBrowserAttachAttempt,
   type MacOsBrowserCreateTabEvidence,
   type MacOsBrowserProduct,
@@ -350,6 +353,15 @@ type PlaywrightRuntime = {
   };
 };
 
+export function browserDependencyRequireAnchors(repoRoot?: string, moduleUrl = import.meta.url): string[] {
+  const releasePackageManifest = join(dirname(fileURLToPath(moduleUrl)), 'package', 'package.json');
+  return [
+    existsSync(releasePackageManifest) ? releasePackageManifest : undefined,
+    repoRoot ? join(repoRoot, 'package.json') : undefined,
+    moduleUrl,
+  ].filter((anchor): anchor is string => typeof anchor === 'string');
+}
+
 interface BrowserPluginRuntimeHooks {
   now(): string;
   moduleAvailable(name: string, repoRoot?: string): boolean;
@@ -407,9 +419,7 @@ const defaultRuntimeHooks: BrowserPluginRuntimeHooks = {
   }),
   connectBrowserCdp: connectNativeBrowserCdp,
   moduleAvailable: (name: string, repoRoot?: string) => {
-    const anchors = [repoRoot ? join(repoRoot, 'package.json') : undefined, import.meta.url]
-      .filter((value): value is string => Boolean(value));
-    for (const anchor of anchors) {
+    for (const anchor of browserDependencyRequireAnchors(repoRoot)) {
       try {
         createRequire(anchor).resolve(name);
         return true;
@@ -420,16 +430,14 @@ const defaultRuntimeHooks: BrowserPluginRuntimeHooks = {
     return false;
   },
   loadPlaywright: (repoRoot?: string) => {
-    const anchors = [repoRoot ? join(repoRoot, 'package.json') : undefined, import.meta.url]
-      .filter((value): value is string => Boolean(value));
-    for (const anchor of anchors) {
+    for (const anchor of browserDependencyRequireAnchors(repoRoot)) {
       try {
         return createRequire(anchor)('playwright') as PlaywrightRuntime;
       } catch {
         // Try the next trusted dependency anchor.
       }
     }
-    throw new AssistantPluginError('PLUGIN_DEPENDENCY_MISSING', 'Browser plugin requires playwright. Run bun install before using browser actions.', {
+    throw new AssistantPluginError('PLUGIN_DEPENDENCY_MISSING', 'Browser plugin cannot resolve packaged Playwright or an authorized repository-local installation.', {
       retryable: false,
     });
   },
@@ -579,7 +587,7 @@ function normalizeConfig(raw: PersistedBrowserPluginConfig): BrowserPluginConfig
     schemaVersion: CURRENT_BROWSER_CONFIG_SCHEMA_VERSION,
     enabled: raw.enabled === true,
     provider: 'playwright',
-    browserMode: browserMode(raw.browserMode) ?? 'managed_persistent',
+    browserMode: browserMode(raw.browserMode) ?? 'attach_preferred',
     profileMode: browserProfileMode(raw.profileMode) ?? (normalizedProfileDir ? 'custom' : 'repo_local'),
     profileDir: normalizedProfileDir,
     profileDirectory: stringValue(raw.profileDirectory),
@@ -591,7 +599,7 @@ function normalizeConfig(raw: PersistedBrowserPluginConfig): BrowserPluginConfig
       ? Math.min(positiveNumber(raw.cdpDiscoveryTimeoutMs, DEFAULT_CDP_DISCOVERY_TIMEOUT_MS), MAX_CDP_DISCOVERY_TIMEOUT_MS)
       : undefined,
     cdpAttachFallback: browserCdpAttachFallback(raw.cdpAttachFallback) ?? 'fail_closed',
-    nativeAttachMode: browserNativeAttachMode(raw.nativeAttachMode) ?? 'disabled',
+    nativeAttachMode: browserNativeAttachMode(raw.nativeAttachMode) ?? 'auto',
     nativeBrowserCandidates: browserProductList(raw.nativeBrowserCandidates) ?? [...DEFAULT_USER_NATIVE_BROWSER_CANDIDATES],
     defaultTimeoutMs: typeof raw.defaultTimeoutMs === 'number' ? positiveNumber(raw.defaultTimeoutMs, DEFAULT_TIMEOUT_MS) : undefined,
   };
@@ -599,23 +607,37 @@ function normalizeConfig(raw: PersistedBrowserPluginConfig): BrowserPluginConfig
 
 function migrateLegacyRepositoryConfig(raw: PersistedBrowserPluginConfig): PersistedBrowserPluginConfig {
   if (raw.schemaVersion === CURRENT_BROWSER_CONFIG_SCHEMA_VERSION) return raw;
-  const configuredCdp = Boolean(
-    stringValue(raw.cdpEndpoint)
-    || (stringList(raw.cdpEndpointCandidates)?.length ?? 0) > 0,
-  );
-  const legacyMode = browserMode(raw.browserMode) ?? 'attach_preferred';
+  // v1 legacy managed profiles were an implicit route to a fresh browser.
+  // Migrate that default to the existing signed-in native browser; preserve
+  // explicit v2 managed configurations as separate scripting capabilities.
+  const legacyV1 = raw.schemaVersion === 1;
   return {
     ...raw,
     schemaVersion: CURRENT_BROWSER_CONFIG_SCHEMA_VERSION,
-    // v1/v2 defaulted to attach_preferred + native auto and silently made
-    // Apple Events JavaScript a global Browser dependency whenever no CDP endpoint
-    // was configured. Preserve explicit CDP attachment, but retire native attach
-    // from migrated defaults; it remains available only when explicitly selected.
-    browserMode: legacyMode === 'attach_preferred' && !configuredCdp ? 'managed_persistent' : legacyMode,
-    nativeAttachMode: 'disabled',
+    browserMode: legacyV1 ? 'attach_preferred' : (browserMode(raw.browserMode) ?? 'attach_preferred'),
+    cdpAttachFallback: legacyV1 ? 'fail_closed' : (raw.cdpAttachFallback ?? 'fail_closed'),
+    nativeAttachMode: legacyV1 ? 'auto' : (raw.nativeAttachMode ?? 'auto'),
+    ...(legacyV1 ? {
+      profileMode: 'repo_local' as const, profileDir: undefined, profileDirectory: undefined,
+      browserChannel: DEFAULT_USER_BROWSER_CHANNEL, nativeBrowserCandidates: [...DEFAULT_USER_NATIVE_BROWSER_CANDIDATES],
+    } : {}),
   };
 }
 
+export function normalizeLegacyBrowserConfig(raw: unknown): BrowserPluginConfig {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+    throw new Error('PLUGIN_CONFIG_MIGRATION_INVALID: browser config must be an object');
+  }
+  const parsed = raw as PersistedBrowserPluginConfig;
+  if (![1, 2, 3].includes(parsed.schemaVersion as number)) {
+    throw new Error('PLUGIN_CONFIG_MIGRATION_INVALID: unsupported browser schemaVersion');
+  }
+  const migrated = normalizeConfig(migrateLegacyRepositoryConfig(parsed));
+  const errors = validateConfig(migrated);
+  if (errors.length) throw new Error(`PLUGIN_CONFIG_MIGRATION_INVALID: ${errors[0]}`);
+  return migrated;
+}
+
 function readJson<T>(path: string): T | undefined {
   try {
     return JSON.parse(readFileSync(path, 'utf-8')) as T;
@@ -629,12 +651,24 @@ function writeJson(path: string, value: unknown): void {
   writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
 }
 
-function loadConfig(repoRoot: string, context?: Pick<RepositoryPluginConfigContext, 'controllerHome' | 'repoId'>): BrowserPluginConfig {
+function loadConfig(
+  repoRoot: string,
+  context?: Pick<RepositoryPluginConfigContext, 'controllerHome' | 'repoId'>,
+  computerNativeOnly = false,
+): BrowserPluginConfig {
+  // Computer Browser is a built-in Forge capability, not an optional
+  // repository Browser-script plugin. Its native defaults ship with the
+  // first-party Computer adapter; never inherit an independent Playwright
+  // profile, enabled flag, CDP endpoint, or fallback from a repository.
+  if (computerNativeOnly) return normalizeConfig({
+    enabled: true, browserMode: 'attach_preferred',
+    nativeAttachMode: 'auto', cdpAttachFallback: 'fail_closed',
+    nativeBrowserCandidates: [...DEFAULT_USER_NATIVE_BROWSER_CANDIDATES],
+  });
   const persisted = context
     ? readRepositoryPluginConfig<PersistedBrowserPluginConfig>({ ...context, repoRoot }, BROWSER_PLUGIN_ID)
     : undefined;
-  if (!persisted) return normalizeConfig({});
-  return normalizeConfig(migrateLegacyRepositoryConfig(persisted));
+  return persisted ? normalizeConfig(migrateLegacyRepositoryConfig(persisted)) : normalizeConfig({});
 }
 
 async function resolveBrowserPluginAuthorizationContextInternal(
@@ -649,7 +683,7 @@ async function resolveBrowserPluginAuthorizationContextInternal(
   // call and left the Scheduler without a durable browser-session grant.
   if (!action || action.confirmation !== 'authorization' || !action.scopes.includes('browser.profile')) return undefined;
 
-  const persistedConfig = loadConfig(input.repoRoot, input);
+  const persistedConfig = loadConfig(input.repoRoot, input, input.pluginId === 'computer');
   const sessionId = stringValue(input.args.session_id);
   const authorizationBrowserMode = parseBrowserModeInput(input.args.browser_mode) ?? persistedConfig.browserMode;
   if (!sessionId || authorizationBrowserMode === 'isolated') return undefined;
@@ -723,6 +757,10 @@ export async function resolveBrowserPluginAuthorizationContext(
 
 function saveConfig(input: Pick<AssistantPluginActionExecutionInput, 'controllerHome' | 'repoId' | 'repoRoot'>, patch: Partial<BrowserPluginConfig>): BrowserPluginConfig {
   const next = normalizeConfig({ ...loadConfig(input.repoRoot, input), ...patch });
+  const errors = validateConfig(next);
+  if (errors.length > 0) {
+    throw new AssistantPluginError('PLUGIN_CONFIGURATION_INVALID', errors[0], { retryable: false });
+  }
   return writeRepositoryPluginConfig(input, BROWSER_PLUGIN_ID, next);
 }
 
@@ -914,11 +952,11 @@ function validateConfig(config: BrowserPluginConfig): string[] {
     const error = cdpEndpointValidationError(endpoint);
     if (error) errors.push(error);
   }
-  if (config.browserMode === 'attach_preferred'
-    && endpoints.length === 0
-    && config.cdpAttachFallback === 'fail_closed'
-    && config.nativeAttachMode === 'disabled') {
-    errors.push('A CDP endpoint or nativeAttachMode=auto is required when browserMode=attach_preferred and cdpAttachFallback=fail_closed.');
+  if (config.browserMode === 'attach_preferred') {
+    if (endpoints.length > 1) errors.push('One Browser attach capability may bind only one CDP endpoint.');
+    if (config.cdpAttachFallback === 'managed_persistent') errors.push('Managed Browser is an explicit browser_mode, never an attach fallback.');
+    // The configured list is discovery scope; execution must bind exactly one
+    // provider from the actual tab/product evidence, never select by fallback.
   }
   return errors;
 }
@@ -931,14 +969,8 @@ function configWarnings(config: BrowserPluginConfig): string[] {
       warnings.push('Custom profile mode is more reliable with an explicit Chrome channel or executable path that matches the selected profile format.');
     }
   }
-  if (config.browserMode === 'attach_preferred' && cdpEndpoints(config).length === 0) {
-    if (config.nativeAttachMode === 'auto' && macOsActiveBrowserAttachSupported()) {
-      warnings.push(config.cdpAttachFallback === 'fail_closed'
-        ? 'browserMode=attach_preferred has no configured CDP endpoint; configured native-browser attach will be attempted and managed fallback is disabled.'
-        : 'browserMode=attach_preferred has no configured CDP endpoint; configured native-browser attach will be attempted before explicit managed fallback.');
-    } else {
-      warnings.push('browserMode=attach_preferred has no configured CDP endpoint; actions will use the configured fallback policy.');
-    }
+  if (config.browserMode === 'attach_preferred' && cdpEndpoints(config).length === 0 && config.nativeAttachMode === 'auto') {
+    warnings.push('Native browser attach is the single selected provider; CDP and managed browsers are not automatic alternatives.');
   }
   if (config.browserMode === 'isolated') {
     warnings.push('browserMode=isolated uses a per-session repo-local profile and will not share the default browser profile.');
@@ -1391,54 +1423,7 @@ function sameOrigin(left: string, right: string): boolean {
   }
 }
 
-function stableBrowserEntityKey(value: string): string | undefined {
-  try {
-    const url = new URL(value);
-    if (url.protocol !== 'https:' && url.protocol !== 'http:') return undefined;
-    const segments = url.pathname.split('/').filter(Boolean);
-    for (let index = 0; index + 1 < segments.length; index += 1) {
-      if ((segments[index] ?? '').toLowerCase() !== 'apps') continue;
-      const id = segments[index + 1]?.trim();
-      if (id) return `${url.origin}/apps/${id}`;
-    }
-    return undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-function selectReusableNativeTab(
-  referenceUrls: string[],
-  inventory: Awaited<ReturnType<typeof listMacOsBrowserTabs>>,
-  preferredWindowId?: string,
-): {
-  candidate?: (typeof inventory.tabs)[number];
-  match: 'exact_url' | 'stable_entity' | 'none' | 'ambiguous';
-  candidateCount: number;
-} {
-  const normalizedReferences = [...new Set(referenceUrls.filter(Boolean).map(comparableUrl))];
-  const entityKeys = new Set(normalizedReferences.map(stableBrowserEntityKey).filter((value): value is string => Boolean(value)));
-  const scored = inventory.tabs.map((candidate) => {
-    const normalizedCandidate = comparableUrl(candidate.url);
-    const entityKey = stableBrowserEntityKey(candidate.url);
-    const matchScore = normalizedReferences.includes(normalizedCandidate)
-      ? 100
-      : entityKey && entityKeys.has(entityKey)
-        ? 50
-        : 0;
-    const score = matchScore === 0
-      ? 0
-      : matchScore + (preferredWindowId && candidate.windowId === preferredWindowId ? 10 : 0) + (candidate.active ? 1 : 0);
-    return { candidate, score, matchScore };
-  });
-  const maxScore = scored.reduce((max, entry) => Math.max(max, entry.score), 0);
-  if (maxScore === 0) return { match: 'none', candidateCount: 0 };
-  const matches = scored.filter((entry) => entry.score === maxScore);
-  if (matches.length !== 1) return { match: 'ambiguous', candidateCount: matches.length };
-  return { candidate: matches[0]!.candidate, match: matches[0]!.matchScore === 100 ? 'exact_url' : 'stable_entity', candidateCount: 1 };
-}
-
-function selectLiveForgeOwnedNativeTab(
+export function selectLiveForgeOwnedNativeTab(
   repoRoot: string,
   targetUrl: string,
   product: MacOsBrowserProduct,
@@ -1464,11 +1449,11 @@ function selectLiveForgeOwnedNativeTab(
   }
 
   const values = [...candidates.values()];
+  if (inventory.truncated) return { match: 'ambiguous', candidateCount: values.length };
   const exact = values.filter(({ candidate }) => comparableUrl(candidate.url) === comparableUrl(targetUrl));
   const choose = (matches: typeof values, match: 'exact_url' | 'same_origin') => {
     if (matches.length === 1) return { ...matches[0], match, candidateCount: 1 } as const;
-    const active = matches.filter(({ candidate }) => candidate.active);
-    if (active.length === 1) return { ...active[0], match, candidateCount: matches.length } as const;
+    // Multiple matching tabs remain ambiguous even when one is active.
     return { match: 'ambiguous' as const, candidateCount: matches.length };
   };
   if (exact.length > 0) return choose(exact, 'exact_url');
@@ -1478,15 +1463,15 @@ function selectLiveForgeOwnedNativeTab(
   return { match: 'none', candidateCount: 0 };
 }
 
-function selectExactNativeTab(
+export function selectExactNativeTab(
   targetUrl: string,
   inventory: Awaited<ReturnType<typeof listMacOsBrowserTabs>>,
 ): { candidate?: (typeof inventory.tabs)[number]; match: 'exact_url' | 'none' | 'ambiguous'; candidateCount: number } {
+  if (inventory.truncated) return { match: 'ambiguous', candidateCount: inventory.tabs.length };
   const matches = inventory.tabs.filter((candidate) => comparableUrl(candidate.url) === comparableUrl(targetUrl));
   if (matches.length === 0) return { match: 'none', candidateCount: 0 };
   if (matches.length === 1) return { candidate: matches[0], match: 'exact_url', candidateCount: 1 };
-  const active = matches.filter((candidate) => candidate.active);
-  if (active.length === 1) return { candidate: active[0], match: 'exact_url', candidateCount: matches.length };
+  // A frontmost tab does not disambiguate two tabs with the same URL.
   return { match: 'ambiguous', candidateCount: matches.length };
 }
 
@@ -1519,7 +1504,7 @@ async function inventoryTabs(context: BrowserContextLike): Promise<BrowserTabInv
   return entries;
 }
 
-function chooseTab(
+export function chooseTab(
   inventory: BrowserTabInventoryEntry[],
   target: BrowserActionTarget,
   options: { allowBlank?: boolean; requireOwnedToken?: boolean } = {},
@@ -1527,6 +1512,20 @@ function chooseTab(
   const desiredUrl = comparableUrl(target.url);
   const savedTab = target.existingSession?.browser?.tab;
   const expectedOwnerToken = savedTab?.ownership === 'plugin_owned' ? savedTab.ownerToken : undefined;
+  const unique = (matches: BrowserTabInventoryEntry[], basis: string): BrowserTabInventoryEntry | undefined => {
+    if (matches.length > 1) {
+      throw new AssistantPluginError('PLUGIN_BROWSER_REUSABLE_TAB_AMBIGUOUS',
+        'Multiple browser tabs satisfy the same lookup; exact tab identity is not proven.',
+        { retryable: false, details: { sessionId: target.sessionId, basis, candidateCount: matches.length } });
+    }
+    return matches[0];
+  };
+  if (options.requireOwnedToken && expectedOwnerToken
+      && inventory.filter((entry) => entry.ownerToken === expectedOwnerToken).length > 1) {
+    throw new AssistantPluginError('PLUGIN_BROWSER_REUSABLE_TAB_AMBIGUOUS',
+      'Multiple browser tabs report the same owned marker.',
+      { retryable: false, details: { sessionId: target.sessionId, basis: 'owned_token' } });
+  }
   if (options.requireOwnedToken) {
     const owned = expectedOwnerToken ? inventory.find((entry) => entry.ownerToken === expectedOwnerToken) : undefined;
     if (owned) {
@@ -1544,25 +1543,8 @@ function chooseTab(
     };
   }
   const savedUrl = savedTab?.url ? comparableUrl(savedTab.url) : undefined;
-  const savedTitle = savedTab?.title;
-  const savedUrlTitle = savedUrl && savedTitle
-    ? inventory.find((entry) => comparableUrl(entry.url) === savedUrl && entry.title === savedTitle)
-    : undefined;
-  if (savedUrlTitle) {
-    return {
-      entry: savedUrlTitle,
-      matchedBy: 'saved_url_title',
-      sessionResume: {
-        sessionId: target.sessionId,
-        status: 'matched',
-        reason: 'Saved tab URL and title matched an attached browser tab.',
-        savedTab,
-      },
-    };
-  }
-
   const savedUrlOnly = savedUrl
-    ? inventory.find((entry) => comparableUrl(entry.url) === savedUrl)
+    ? unique(inventory.filter((entry) => comparableUrl(entry.url) === savedUrl), 'saved_url')
     : undefined;
   if (savedUrlOnly) {
     return {
@@ -1571,13 +1553,13 @@ function chooseTab(
       sessionResume: {
         sessionId: target.sessionId,
         status: savedTab ? 'matched' : 'no_saved_tab',
-        reason: savedTab ? 'Saved tab URL matched but the previous title was not present.' : 'No saved tab metadata was available.',
+        reason: savedTab ? 'Saved tab URL was unique in this browser context; page title was not used as identity.' : 'No saved tab metadata was available.',
         savedTab,
       },
     };
   }
 
-  const exactUrl = inventory.find((entry) => comparableUrl(entry.url) === desiredUrl);
+  const exactUrl = unique(inventory.filter((entry) => comparableUrl(entry.url) === desiredUrl), 'exact_url');
   if (exactUrl) {
     return {
       entry: exactUrl,
@@ -1597,7 +1579,7 @@ function chooseTab(
     };
   }
 
-  const blank = options.allowBlank === false ? undefined : inventory.find((entry) => isBlankPage(entry.url));
+  const blank = options.allowBlank === false ? undefined : unique(inventory.filter((entry) => isBlankPage(entry.url)), 'blank');
   if (blank) {
     return {
       entry: blank,
@@ -2627,15 +2609,13 @@ async function openNativeAttachedContext(
   args: Record<string, unknown>,
 ): Promise<{ handle?: BrowserOpenHandle; attempts: MacOsBrowserAttachAttempt[] }> {
   if (config.nativeAttachMode === 'disabled') return { attempts: [] };
-  if (!target.existingSession && !stringValue(args.session_id)) {
+  if (!target.existingSession && !stringValue(args.session_id) && args.__forge_computer_native_only !== true) {
     await inspectNativeOwnedSessions({ repoRoot, savedSessions: listSavedSessions(repoRoot), timeoutMs: config.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS, pruneDead: true });
   }
   const timeout = positiveNumber(args.timeout_ms, config.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS);
   const savedTab = target.existingSession?.browser?.tab;
   const savedOwnership = savedTab?.ownership;
   let effectiveOwnership = savedOwnership;
-  let recoveredTabTitle = '';
-  let recoveredTabUrl: string | undefined;
   const savedProduct = target.existingSession?.browser?.provider === 'macos-apple-events'
     && savedTab
     && (savedOwnership === 'plugin_owned' || savedOwnership === 'user_owned')
@@ -2685,63 +2665,18 @@ async function openNativeAttachedContext(
         savedTab,
       };
     } catch (error) {
-      if (error instanceof AssistantPluginError
-        && error.code === 'PLUGIN_BROWSER_NATIVE_TAB_IDENTITY_UNPROVEN'
-        && savedOwnership === 'user_owned') {
+      // URL/title or a formerly active window cannot identify a lost native tab.
+      // Never silently adopt another user's tab or create a replacement for a saved session.
+      if (savedOwnership === 'user_owned' && error instanceof AssistantPluginError && error.code === 'PLUGIN_BROWSER_NATIVE_TAB_IDENTITY_UNPROVEN') {
         throw error;
       }
-      if (savedOwnership === 'user_owned') {
-        throw new AssistantPluginError(
-          'PLUGIN_BROWSER_SESSION_STATE_LOST',
-          'Explicitly adopted user-owned macOS browser tab no longer exists; refusing to silently switch to another user tab.',
-          {
-            retryable: false,
-            details: { sessionId: target.sessionId, browserProduct: savedProduct, ownership: savedOwnership, windowId: savedTab.windowId, tabId: savedTab.tabId, cause: error instanceof Error ? error.message : String(error) },
-          },
-        );
-      }
-      let inventory: Awaited<ReturnType<typeof listMacOsBrowserTabs>> | undefined;
-      let selection: ReturnType<typeof selectReusableNativeTab> | undefined;
-      let recoveryFailure: string | undefined;
-      try {
-        inventory = await listMacOsBrowserTabs(savedProduct, timeout);
-        selection = selectReusableNativeTab(
-          [savedTab.url, target.existingSession?.url ?? '', target.url],
-          inventory,
-          savedTab.windowId,
-        );
-        if (selection.candidate) {
-          const recovered = await reattachMacOsBrowserOwnedPage(savedProduct, { windowId: selection.candidate.windowId, tabId: selection.candidate.tabId }, timeout);
-          page = recovered.page as unknown as PageLike;
-          discovered = { attachment: recovered.attachment, attempts: recovered.attachment.attempts };
-          matchedBy = 'recovered_tab';
-          effectiveOwnership = 'user_owned';
-          recoveredTabTitle = selection.candidate.title;
-          recoveredTabUrl = selection.candidate.url;
-          sessionResume = {
-            sessionId: target.sessionId,
-            status: 'matched',
-            reason: selection.match === 'exact_url'
-              ? 'Saved plugin-owned tab disappeared; rebound safely to the unique currently open tab with the same URL and preserved it as user-owned.'
-              : 'Saved plugin-owned tab disappeared; rebound safely to the unique currently open tab for the same stable app entity and preserved its current page as user-owned.',
-            savedTab,
-          };
-        }
-      } catch (recoveryError) {
-        recoveryFailure = recoveryError instanceof Error ? recoveryError.message : String(recoveryError);
-      }
-      if (!page) {
-        sessionResume = {
-          sessionId: target.sessionId,
-          status: 'stale_tab',
-          reason: recoveryFailure
-            ? `Saved plugin-owned macOS browser tab disappeared and current-tab recovery failed (${recoveryFailure}); creating one replacement plugin-owned tab.`
-            : selection?.match === 'ambiguous'
-              ? 'Saved plugin-owned macOS browser tab disappeared and multiple reusable current tabs matched; refusing to guess between user tabs and creating one replacement plugin-owned tab.'
-              : 'Saved plugin-owned macOS browser tab disappeared and no uniquely reusable current tab matched; creating one replacement plugin-owned tab.',
-          savedTab,
-        };
-      }
+      throw new AssistantPluginError('PLUGIN_BROWSER_SESSION_STATE_LOST',
+        'Saved native browser tab could not be reattached by its exact identity; refusing URL-based recovery or replacement.',
+        { retryable: false, details: {
+          sessionId: target.sessionId, browserProduct: savedProduct, ownership: savedOwnership,
+          windowId: savedTab.windowId, tabId: savedTab.tabId,
+          causeCode: error instanceof AssistantPluginError ? error.code : 'NATIVE_REATTACH_FAILED',
+        } });
     }
   } else {
     sessionResume = savedTab
@@ -2749,11 +2684,105 @@ async function openNativeAttachedContext(
       : { sessionId: target.sessionId, status: 'no_saved_tab', reason: 'Created one plugin-owned tab while preserving the user active tab.' };
   }
 
+  // Session-bound reads and mutations must never turn a dead tab into a new
+  // tab or silently select another profile. The explicit open-page route is
+  // separate and retains its documented create/recover semantics.
+  if (args.__forge_require_existing_resource === true && target.existingSession && !page) {
+    throw new AssistantPluginError(
+      'PLUGIN_BROWSER_SESSION_STATE_LOST',
+      'The saved native browser tab is unavailable and no exact existing tab can be verified; the session was not moved to another profile or recreated.',
+      { retryable: false, details: {
+        sessionId: target.sessionId, browserProduct: savedProduct,
+        savedWindowId: savedTab?.windowId, savedTabId: savedTab?.tabId,
+      } },
+    );
+  }
   let createdThisCallRef: MacOsBrowserTabRef | undefined;
+  let preferredNativeWindowId: string | undefined;
   if (!discovered?.attachment) {
     const candidates = savedProduct ? [savedProduct] : (config.nativeBrowserCandidates ?? [...DEFAULT_USER_NATIVE_BROWSER_CANDIDATES]);
-    discovered = await discoverMacOsBrowserAttachment(candidates, Math.min(timeout, MAX_CDP_DISCOVERY_TIMEOUT_MS));
+    let preferredCandidates = candidates;
+    if (candidates.length > 1 && !target.existingSession && (args.__forge_computer_native_only === true || !stringValue(args.session_id))) {
+      // Choosing the frontmost browser can select a different, signed-out
+      // profile even while the user's matching Chrome tab is in the background.
+      // Prefer exact URL evidence across *all* configured native products.
+      const inventories = await Promise.all(candidates.map(async (product) => {
+        try { await assertMacOsBrowserApplicationRunning(product, timeout); }
+        catch (error) {
+          if (error instanceof AssistantPluginError && [
+            'PLUGIN_BROWSER_NATIVE_APP_NOT_RUNNING', 'PLUGIN_BROWSER_NATIVE_APP_NOT_INSTALLED',
+            'PLUGIN_BROWSER_NATIVE_APP_UNSUPPORTED_PLATFORM',
+          ].includes(error.code)) return undefined;
+          throw error;
+        }
+        try {
+          const inventory = await listMacOsBrowserTabs(product, timeout, { correctFrontmost: false });
+          if (inventory.truncated) throw new AssistantPluginError('PLUGIN_COMPUTER_BROWSER_INVENTORY_INCOMPLETE',
+            'Native browser inventory truncated; cannot prove the existing target tab is absent.',
+            { retryable: true, details: { browserProduct: product } });
+          return { product, inventory };
+        } catch (error) {
+          // Unreadable background tabs are not absent tabs: no replacement
+          // browser or new tab may be created from an incomplete inventory.
+          if (args.__forge_computer_native_only === true) {
+            throw new AssistantPluginError('PLUGIN_COMPUTER_BROWSER_INVENTORY_UNAVAILABLE',
+              'Cannot enumerate existing native browser tabs; refusing to create a duplicate.',
+              { retryable: true, details: { browserProduct: product, cause: error instanceof Error ? error.message : String(error) } });
+          }
+          return undefined;
+        }
+      }));
+      const observed = inventories.filter((item): item is NonNullable<typeof item> => Boolean(item));
+      const exact = observed.flatMap(({ product, inventory }) => inventory.tabs
+        .filter((entry) => comparableUrl(entry.url) === comparableUrl(target.url))
+        .map((entry) => ({ product, entry })));
+      if (exact.length > 1) {
+        throw new AssistantPluginError('PLUGIN_BROWSER_REUSABLE_TAB_AMBIGUOUS',
+          'Multiple browser products have existing tabs for the exact URL; refusing to guess and create another tab.',
+          { retryable: false, details: { targetUrl: target.url, candidateCount: exact.length } });
+      }
+      if (exact.length === 1) {
+        preferredCandidates = [exact[0]!.product];
+      } else {
+        // Same-origin tabs only identify a likely browser *profile*, not an
+        // exact resource. A new tab may be created there, but never overwrite
+        // an unrelated user tab or invent proof of authentication.
+        const origin = (() => { try { return new URL(target.url).origin; } catch { return ''; } })();
+        const originProducts = observed.filter(({ inventory }) => origin && inventory.tabs.some((entry) => {
+          try { return new URL(entry.url).origin === origin; } catch { return false; }
+        })).map(({ product }) => product);
+        if (originProducts.length === 1) {
+          preferredCandidates = [originProducts[0]!];
+          const matchingWindows = new Set(observed
+            .filter(({ product }) => product === originProducts[0])
+            .flatMap(({ inventory }) => inventory.tabs.filter((entry) => {
+              try { return new URL(entry.url).origin === origin; } catch { return false; }
+            }).map((entry) => entry.windowId)));
+          if (matchingWindows.size === 1) preferredNativeWindowId = [...matchingWindows][0];
+        } else if (observed.length === 1) {
+          // Exactly one available browser product is observed. Product discovery
+          // must not silently fall through multiple provider backends.
+          preferredCandidates = [observed[0]!.product];
+        } else if (observed.length === 0) {
+          throw new AssistantPluginError(args.__forge_computer_native_only === true
+            ? 'PLUGIN_COMPUTER_NATIVE_BROWSER_UNAVAILABLE' : 'PLUGIN_BROWSER_ATTACH_UNAVAILABLE',
+            'No usable existing native browser was observed; refusing to launch or guess a provider.',
+            { retryable: false });
+        } else {
+          if (args.__forge_require_existing_resource === true) {
+            throw new AssistantPluginError('PLUGIN_BROWSER_EXISTING_TAB_NOT_FOUND',
+              'No uniquely reusable tab matches the requested existing resource; refusing new tab creation.',
+              { retryable: false });
+          }
+          throw new AssistantPluginError('PLUGIN_BROWSER_PROVIDER_CARDINALITY_INVALID',
+            'No uniquely identified existing browser product; refusing implicit cross-provider selection.',
+            { retryable: false, details: { candidateCount: observed.length } });
+        }
+      }
+    }
+    discovered = await discoverMacOsBrowserAttachment(preferredCandidates, Math.min(timeout, MAX_CDP_DISCOVERY_TIMEOUT_MS));
     const zeroWindowAttempt = args.__forge_require_existing_resource !== true
+      && args.__forge_computer_native_only !== true
       ? discovered.attempts.find((attempt) => attempt.status === 'unavailable' && attempt.error?.includes('FORGE_NO_BROWSER_WINDOW'))
       : undefined;
     if (!discovered.attachment && zeroWindowAttempt) {
@@ -2870,12 +2899,17 @@ async function openNativeAttachedContext(
     }
   };
   try {
-    if (!page && !savedTab && !stringValue(args.session_id)) {
+    if (!page && !savedTab && !target.existingSession && (args.__forge_computer_native_only === true || !stringValue(args.session_id))) {
       let inventory: Awaited<ReturnType<typeof listMacOsBrowserTabs>> | undefined;
       try {
         inventory = await listMacOsBrowserTabs(activeAttachment.metadata.product, timeout);
       } catch (error) {
         if (!nativeTabInventoryUnsupported(error)) throw error;
+        if (args.__forge_computer_native_only === true) {
+          throw new AssistantPluginError('PLUGIN_COMPUTER_BROWSER_INVENTORY_UNAVAILABLE',
+            'Native tab inventory unavailable; Computer cannot prove an existing tab is absent.',
+            { retryable: true });
+        }
       }
       if (inventory) {
         const ownedSelection = selectLiveForgeOwnedNativeTab(repoRoot, target.url, activeAttachment.metadata.product, inventory);
@@ -2929,8 +2963,6 @@ async function openNativeAttachedContext(
             activeAttachment = rebound.attachment;
             matchedBy = 'exact_url';
             effectiveOwnership = 'user_owned';
-            recoveredTabTitle = exactSelection.candidate.title;
-            recoveredTabUrl = exactSelection.candidate.url;
             sessionResume = {
               sessionId: target.sessionId,
               status: 'matched',
@@ -2941,7 +2973,23 @@ async function openNativeAttachedContext(
       }
     }
     if (!page) {
-      page = await createMacOsBrowserOwnedPage(activeAttachment, target.url, timeout) as unknown as PageLike;
+      // Explicit existing-resource requests (including read-only live
+      // acceptance) must never create a new tab if no exact tab was found.
+      if (!target.existingSession && args.__forge_require_existing_resource === true) {
+        throw new AssistantPluginError('PLUGIN_BROWSER_EXISTING_TAB_NOT_FOUND',
+          'No uniquely reusable native tab matches the requested URL; refusing to create a new tab.',
+          { retryable: false });
+      }
+      if (preferredNativeWindowId) {
+        const created = await createMacOsBrowserOwnedPageForProduct(
+          activeAttachment.metadata.product, target.url, activeAttachment.attempts, preferredNativeWindowId, timeout,
+        );
+        page = created.page as unknown as PageLike;
+        activeAttachment = created.attachment;
+        discovered = { attachment: created.attachment, attempts: created.attachment.attempts };
+      } else {
+        page = await createMacOsBrowserOwnedPage(activeAttachment, target.url, timeout) as unknown as PageLike;
+      }
       createdThisCallRef = (page as unknown as { tabRef?: () => MacOsBrowserTabRef | undefined }).tabRef?.();
       const liveIdentity = await settleNativeCreatedPageIdentity(
         page as unknown as {
@@ -2961,21 +3009,15 @@ async function openNativeAttachedContext(
     if (comparableUrl(page.url()) !== comparableUrl(target.url) && !explicitUserOwnedUrlMatch) {
       const currentRef = (page as unknown as { tabRef?: () => MacOsBrowserTabRef | undefined }).tabRef?.();
       if (effectiveOwnership === 'user_owned') {
-        if (matchedBy === 'recovered_tab') {
-          sessionResume = { sessionId: target.sessionId, status: 'matched', reason: 'Recovered current user tab was already within the same saved app entity; preserved its current URL instead of navigating it.', savedTab };
-        } else {
-          throw new AssistantPluginError(
-            'PLUGIN_BROWSER_ADOPTED_TAB_URL_MISMATCH',
-            'Explicitly adopted user-owned tab no longer matches the saved session URL; refusing to navigate, replace, or close the user tab.',
-            { retryable: true, details: { sessionId: target.sessionId, expectedUrl: target.url, actualUrl: page.url(), windowId: savedTab?.windowId, tabId: savedTab?.tabId } },
-          );
-        }
+        throw new AssistantPluginError(
+          'PLUGIN_BROWSER_ADOPTED_TAB_URL_MISMATCH',
+          'Explicitly adopted user-owned tab no longer matches the saved session URL; refusing to navigate, replace, or close the user tab.',
+          { retryable: true, details: { sessionId: target.sessionId, expectedUrl: target.url, actualUrl: page.url(), windowId: savedTab?.windowId, tabId: savedTab?.tabId } },
+        );
       }
       const sessionTargetUnchanged = Boolean(target.existingSession?.url) && comparableUrl(target.url) === comparableUrl(target.existingSession?.url ?? '');
       const preserveOwnedSameOriginDrift = matchedBy === 'owned_token' && sessionTargetUnchanged && sameOrigin(page.url(), target.url);
-      if (matchedBy === 'recovered_tab' && effectiveOwnership === 'user_owned') {
-        // Safe recovery adopts an already-open tab. Its current page is authoritative and must not be navigated.
-      } else if (preserveOwnedSameOriginDrift) {
+      if (preserveOwnedSameOriginDrift) {
         sessionResume = { sessionId: target.sessionId, status: 'matched', reason: 'Plugin-owned tab navigated within the same origin; preserved the live tab and refreshed its session URL.', savedTab };
       } else {
         page = await navigateNativePageWithReplacement(page);
@@ -2993,13 +3035,13 @@ async function openNativeAttachedContext(
     if (matchedBy !== 'owned_token' && page.waitForLoadState && !explicitInternalUserSession) {
       await page.waitForLoadState(waitUntil(args.wait_until), { timeout });
     }
-    const observedPageUrl = matchedBy === 'recovered_tab' && recoveredTabUrl ? recoveredTabUrl : page.url();
+    const observedPageUrl = page.url();
     const pageUrl = explicitInternalUserSession
       ? normalizedExplicitNativeAdoptionUrl(observedPageUrl)
       : normalizedUrl(observedPageUrl);
     const nativeRef = (page as unknown as { tabRef?: () => MacOsBrowserTabRef | undefined }).tabRef?.();
     if (!nativeRef) throw new AssistantPluginError('PLUGIN_BROWSER_NATIVE_OWNERSHIP_MISSING', 'Native browser did not return a stable plugin-owned tab reference.', { retryable: true });
-    const title = matchedBy === 'owned_token' ? (target.existingSession?.title ?? '') : matchedBy === 'recovered_tab' ? recoveredTabTitle : '';
+    const title = matchedBy === 'owned_token' ? (target.existingSession?.title ?? '') : '';
     const inventory: BrowserTabInventoryEntry[] = [{ index: 0, key: tabKey(pageUrl, title), url: pageUrl, title }];
     const metadata = activeAttachment.metadata;
     // The live exact-tab URL is authoritative after a safe native rebind. Keep the
@@ -3042,80 +3084,66 @@ async function openBrowser(
   target: BrowserActionTarget,
   args: Record<string, unknown>,
 ): Promise<BrowserOpenHandle> {
-  const requestedMode = config.browserMode ?? 'managed_persistent';
+  const computerNativeOnly = args.__forge_computer_native_only === true;
+  const requestedMode = computerNativeOnly ? 'attach_preferred' : (config.browserMode ?? 'attach_preferred');
+  if (computerNativeOnly) {
+    // Computer operates existing desktop/browser resources. Playwright CDP and
+    // managed profiles remain exclusive to explicitly selected Browser scripts.
+    if (target.existingSession?.browser?.provider
+      && target.existingSession.browser.provider !== 'macos-apple-events') {
+      throw new AssistantPluginError('PLUGIN_COMPUTER_BROWSER_PROVIDER_MISMATCH',
+        'This saved session belongs to an independent scripted Browser provider; Computer cannot silently adopt or replace it.',
+        { retryable: false, details: { sessionId: target.sessionId, provider: target.existingSession.browser.provider } });
+    }
+    const native = await openNativeAttachedContext(repoRoot, {
+      ...config, browserMode: 'attach_preferred', nativeAttachMode: 'auto', cdpAttachFallback: 'fail_closed',
+    }, target, args);
+    if (native.handle) return native.handle;
+    throw new AssistantPluginError('PLUGIN_COMPUTER_NATIVE_BROWSER_UNAVAILABLE',
+      'No attachable existing Chrome or Vivaldi browser is available. Computer will not start a Playwright profile.',
+      { retryable: true, details: { nativeAttempts: native.attempts } });
+  }
   if (requestedMode === 'attach_preferred') {
-    const requireExistingResource = args.__forge_require_existing_resource === true;
-    const existingProvider = target.existingSession?.browser?.provider;
-    const attached = cdpEndpoints(config).length > 0 && runtimeHooks.moduleAvailable('playwright', repoRoot)
-      ? await openAttachedContext(runtimeHooks.loadPlaywright(repoRoot), repoRoot, config, target, args)
-      : { attempts: [] as CdpAttachAttempt[] };
-    if (attached.handle) return attached.handle;
-    if (requireExistingResource && existingProvider === 'playwright-cdp') {
-      throw new AssistantPluginError(
-        'PLUGIN_BROWSER_SESSION_STATE_LOST',
-        'Saved CDP browser page is no longer attachable; refusing to fall back to another browser or create a replacement page.',
-        { retryable: false, details: { sessionId: target.sessionId, provider: existingProvider } },
-      );
+    const savedProvider = target.existingSession?.browser?.provider;
+    if (savedProvider === 'playwright-persistent-context') {
+      throw new AssistantPluginError('PLUGIN_BROWSER_SESSION_STATE_LOST',
+        'A managed session cannot be silently adopted by an attach provider. Select managed_persistent explicitly.',
+        { retryable: false, details: { sessionId: target.sessionId, provider: savedProvider } });
     }
-    if (requireExistingResource && existingProvider === 'playwright-persistent-context') {
+    const endpoints = cdpEndpoints(config);
+    const route = savedProvider === 'macos-apple-events' ? 'native'
+      : savedProvider === 'playwright-cdp' || endpoints.length > 0 ? 'cdp' : 'native';
+    if (route === 'cdp') {
+      if (endpoints.length !== 1) {
+        throw new AssistantPluginError('PLUGIN_BROWSER_PROVIDER_CARDINALITY_INVALID',
+          'CDP attach requires exactly one configured endpoint.', { retryable: false });
+      }
       if (!runtimeHooks.moduleAvailable('playwright', repoRoot)) {
-        throw new AssistantPluginError('PLUGIN_BROWSER_DEPENDENCY_UNAVAILABLE', 'Managed browser mode requires Playwright.', { retryable: false });
+        throw new AssistantPluginError('PLUGIN_BROWSER_DEPENDENCY_UNAVAILABLE',
+          'Selected CDP provider requires Playwright; no other provider will be attempted.', { retryable: false });
       }
-      return openManagedContext(runtimeHooks.loadPlaywright(repoRoot), repoRoot, config, target, args, 'managed_persistent', requestedMode, {
-        policy: config.cdpAttachFallback ?? 'fail_closed',
-        from: 'attach_preferred',
-        to: 'managed_persistent',
-        reason: 'Reusing the existing managed fallback session without probing or creating a different browser resource.',
-        attempts: attached.attempts,
-      });
+      const attached = await openAttachedContext(runtimeHooks.loadPlaywright(repoRoot), repoRoot, config, target, args);
+      if (attached.handle) return attached.handle;
+      throw new AssistantPluginError('PLUGIN_BROWSER_ATTACH_UNAVAILABLE',
+        'Configured CDP endpoint unavailable. Native and managed providers will not be attempted.',
+        { retryable: true, details: { provider: 'playwright-cdp', attempts: attached.attempts } });
+    }
+    if (config.nativeAttachMode !== 'auto') {
+      throw new AssistantPluginError('PLUGIN_BROWSER_ATTACH_UNAVAILABLE',
+        'Native attach is not configured. Choose an explicit Browser mode or one CDP endpoint.',
+        { retryable: false });
     }
-
     const native = await openNativeAttachedContext(repoRoot, config, target, args);
     if (native.handle) return native.handle;
-    if (requireExistingResource) {
-      throw new AssistantPluginError(
-        'PLUGIN_BROWSER_SESSION_STATE_LOST',
-        'Saved browser resource is no longer attachable; refusing to create a replacement tab/page for this existing-session action.',
-        { retryable: false, details: { sessionId: target.sessionId, provider: existingProvider } },
-      );
-    }
-
-    const fallbackPolicy = config.cdpAttachFallback ?? 'fail_closed';
-    const cdpReason = attached.attempts.map((attempt) => `${attempt.endpoint}: ${attempt.error ?? 'unavailable'}`).join('; ')
-      || 'No CDP endpoint candidates were configured.';
-    const nativeReason = native.attempts.map((attempt) => `${attempt.appName}: ${attempt.error ?? attempt.status}`).join('; ')
-      || (config.nativeAttachMode === 'disabled' ? 'Native browser attach is disabled.' : 'No scriptable macOS browser was available.');
-    const reason = `CDP: ${cdpReason} Native: ${nativeReason}`;
-    if (fallbackPolicy === 'fail_closed') {
-      throw new AssistantPluginError('PLUGIN_BROWSER_ATTACH_UNAVAILABLE', `No configured browser attach provider was available. Fallback policy fail_closed prevented managed launch. ${reason}`, {
-        retryable: true,
-        details: {
-          browserMode: requestedMode,
-          fallbackPolicy,
-          attempts: attached.attempts,
-          nativeAttempts: native.attempts,
-        },
-      });
-    }
-    if (!runtimeHooks.moduleAvailable('playwright', repoRoot)) {
-      throw new AssistantPluginError('PLUGIN_BROWSER_DEPENDENCY_UNAVAILABLE', `Managed browser fallback requires Playwright, but native/CDP attach was unavailable. ${reason}`, { retryable: false });
-    }
-    return openManagedContext(runtimeHooks.loadPlaywright(repoRoot), repoRoot, config, target, args, 'managed_persistent', requestedMode, {
-      policy: fallbackPolicy,
-      from: 'attach_preferred',
-      to: 'managed_persistent',
-      reason,
-      attempts: attached.attempts,
-      nativeAttempts: native.attempts,
-    });
+    throw new AssistantPluginError('PLUGIN_BROWSER_ATTACH_UNAVAILABLE',
+      'Configured native browser target unavailable. No alternate provider will be attempted.',
+      { retryable: true, details: { provider: 'macos-apple-events', attempts: native.attempts } });
   }
-
   if (!runtimeHooks.moduleAvailable('playwright', repoRoot)) {
     throw new AssistantPluginError('PLUGIN_BROWSER_DEPENDENCY_UNAVAILABLE', 'Managed browser mode requires Playwright.', { retryable: false });
   }
   return openManagedContext(runtimeHooks.loadPlaywright(repoRoot), repoRoot, config, target, args, requestedMode, requestedMode);
 }
-
 async function withPage<T>(
   actionId: string,
   repoRoot: string,
@@ -3875,9 +3903,12 @@ function health(config: BrowserPluginConfig, repoRoot?: string): AssistantPlugin
   };
 }
 
-export function buildBrowserPluginManifest(previousRevision = 0, previousUpdatedAt?: string, repoRoot?: string, context?: AssistantPluginBuildContext): AssistantPluginManifest {
+export function buildBrowserPluginManifest(
+  previousRevision = 0, previousUpdatedAt?: string, repoRoot?: string,
+  context?: AssistantPluginBuildContext, computerNativeOnly = false,
+): AssistantPluginManifest {
   const root = repoRoot ?? process.cwd();
-  const config = loadConfig(root, context);
+  const config = loadConfig(root, context, computerNativeOnly);
   const state = health(config, root);
   return {
     schemaVersion: 1,
@@ -3899,9 +3930,7 @@ export function buildBrowserPluginManifest(previousRevision = 0, previousUpdated
         ? 'Browser plugin is disabled.'
         : state.ready
           ? `Browser plugin is ready via ${config.browserMode === 'attach_preferred'
-            ? config.cdpAttachFallback === 'managed_persistent'
-              ? 'CDP, macOS native attach, and explicit managed fallback.'
-              : 'CDP or macOS native attach; managed fallback is disabled.'
+            ? 'the one configured CDP or native browser target (no provider fallback).'
             : 'Playwright persistent context.'}`
           : state.state === 'degraded'
             ? state.warnings[0] ?? 'Browser plugin requires a successful live native attach probe.'
@@ -3915,13 +3944,6 @@ export function buildBrowserPluginManifest(previousRevision = 0, previousUpdated
   };
 }
 
-const NODE_BRIDGE_PRE_ACTION_FAILURE_CODES = new Set([
-  'PLUGIN_BROWSER_NODE_UNAVAILABLE',
-  'PLUGIN_BROWSER_NODE_HOST_UNAVAILABLE',
-  'PLUGIN_BROWSER_NODE_REQUEST_TOO_LARGE',
-  'PLUGIN_BROWSER_NODE_START_FAILED',
-]);
-
 function browserRuntimeKey(input: AssistantPluginActionExecutionInput): string {
   return `${input.controllerHome}:${input.repoId}`;
 }
@@ -3930,9 +3952,15 @@ async function executeBrowserPluginActionInternal(
   input: AssistantPluginActionExecutionInput,
   runtimeAlreadyRouted = false,
 ): Promise<Record<string, unknown>> {
-  const persisted = loadConfig(input.repoRoot, input);
+  const persisted = loadConfig(input.repoRoot, input, input.pluginId === 'computer');
   const actionSessionId = input.actionId === 'configure' ? undefined : stringValue(input.args.session_id);
   const actionSession = actionSessionId ? findBrowserSession(input.repoRoot, actionSessionId) : undefined;
+  if (input.pluginId === 'computer' && actionSession?.browser?.provider
+    && actionSession.browser.provider !== 'macos-apple-events') {
+    throw new AssistantPluginError('PLUGIN_COMPUTER_BROWSER_PROVIDER_MISMATCH',
+      'Computer cannot manage an independent scripted Browser session; use the Browser plugin for that session.',
+      { retryable: false, details: { sessionId: actionSessionId, provider: actionSession.browser.provider } });
+  }
   const current = input.actionId === 'configure' ? persisted : effectiveBrowserActionConfig(persisted, input.args, actionSession);
   if (!current.enabled && input.actionId !== 'configure') {
     throw new AssistantPluginError('PLUGIN_DISABLED', 'Browser plugin is disabled.', { retryable: false });
@@ -3945,7 +3973,7 @@ async function executeBrowserPluginActionInternal(
   }
   if (!runtimeAlreadyRouted) {
     const runtimeKey = browserRuntimeKey(input);
-    const nodeBridgeEligible = shouldUseBrowserNodeBridge(
+    const nodeBridgeEligible = input.pluginId !== 'computer' && shouldUseBrowserNodeBridge(
       input.actionId,
       current.browserMode,
       runtimeHooksCustomized,
@@ -3954,33 +3982,21 @@ async function executeBrowserPluginActionInternal(
     const result = await executeBrowserRuntimeAction({
       runtimeKey,
       input,
-      providers: [
-        ...(nodeBridgeEligible ? [{
+      providers: nodeBridgeEligible ? [{
           providerId: 'browser.node_bridge',
           capabilities: ALL_BROWSER_PROVIDER_CAPABILITIES.filter((capability) => capability !== 'browser.persistent_handle'),
           foreground: 'none' as const,
           verifiesPostconditions: true,
           persistentHandle: false,
-          priority: 10,
           supportsInput: () => true,
-          execute: async (routedInput: AssistantPluginActionExecutionInput) => {
-            try {
-              return await executeBrowserActionThroughNode(routedInput);
-            } catch (error) {
-              if (error instanceof AssistantPluginError && NODE_BRIDGE_PRE_ACTION_FAILURE_CODES.has(error.code)) {
-                throw new BrowserProviderUnavailableBeforeActionError('browser.node_bridge', error.code);
-              }
-              throw error;
-            }
-          },
-        }] : []),
+          execute: async (routedInput: AssistantPluginActionExecutionInput) => await executeBrowserActionThroughNode(routedInput),
+        }] : [
         {
           providerId: 'browser.local',
           capabilities: ALL_BROWSER_PROVIDER_CAPABILITIES,
           foreground: 'none' as const,
           verifiesPostconditions: true,
           persistentHandle: true,
-          priority: 20,
           supportsInput: () => true,
           execute: async (routedInput: AssistantPluginActionExecutionInput) => executeBrowserPluginActionInternal(routedInput, true),
         },
@@ -4032,10 +4048,6 @@ async function executeBrowserPluginActionInternal(
             ? positiveNumber(args.default_timeout_ms, DEFAULT_TIMEOUT_MS)
             : current.defaultTimeoutMs,
         });
-        const configErrors = validateConfig(config);
-        if (configErrors.length > 0) {
-          throw new AssistantPluginError('PLUGIN_CONFIGURATION_INVALID', configErrors[0], { retryable: false });
-        }
         await closeManagedContextsForRepo(input.repoRoot);
         return { config, health: health(config, input.repoRoot) };
       }
@@ -4118,7 +4130,10 @@ async function executeBrowserPluginActionInternal(
             throw new AssistantPluginError('PLUGIN_BROWSER_SESSION_CURSOR_INVALID', 'Browser session cursor is invalid or expired.', { retryable: false });
           }
         }
-        const page = inventory.sessions.slice(offset, offset + requestedLimit);
+        const visibleSessions = input.pluginId === 'computer'
+          ? inventory.sessions.filter(({ session }) => session.browser?.provider === 'macos-apple-events')
+          : inventory.sessions;
+        const page = visibleSessions.slice(offset, offset + requestedLimit);
         const nextOffset = offset + page.length;
         return {
           provider: 'playwright',
@@ -4131,8 +4146,8 @@ async function executeBrowserPluginActionInternal(
           deadManagedSessionCount: inventory.deadManagedSessionCount,
           deadNativeSessionCount: inventory.deadNativeSessionCount,
           limit: requestedLimit,
-          totalCount: inventory.sessions.length,
-          ...(nextOffset < inventory.sessions.length ? { nextCursor: Buffer.from(JSON.stringify({ offset: nextOffset }), 'utf8').toString('base64url') } : {}),
+          totalCount: visibleSessions.length,
+          ...(nextOffset < visibleSessions.length ? { nextCursor: Buffer.from(JSON.stringify({ offset: nextOffset }), 'utf8').toString('base64url') } : {}),
           sessions: page.map(({ session, liveness, evidence, cleanupError }) => ({
             sessionId: session.sessionId,
             url: session.url,
@@ -4217,7 +4232,13 @@ async function executeBrowserPluginActionInternal(
       case 'request_human_handoff': {
         const target = resolveActionTarget(input.repoRoot, input.args);
         const managedSession = target.existingSession;
-        const managedTarget = managedSession ? await runtimeManagedPageForSession(input.repoRoot, current, managedSession) : undefined;
+        if (input.pluginId === 'computer' && managedSession?.browser?.provider
+          && managedSession.browser.provider !== 'macos-apple-events') {
+          throw new AssistantPluginError('PLUGIN_COMPUTER_BROWSER_PROVIDER_MISMATCH',
+            'Computer handoff requires a native browser tab, not a scripted Browser session.', { retryable: false });
+        }
+        const managedTarget = input.pluginId === 'computer'
+          ? undefined : managedSession ? await runtimeManagedPageForSession(input.repoRoot, current, managedSession) : undefined;
         if (managedSession && managedTarget) {
           const result = { url: managedTarget.page.url(), title: await managedTarget.page.title().catch(() => managedSession.title) };
           const handoff = startRuntimeManagedBrowserHandoff({
@@ -4254,7 +4275,7 @@ async function executeBrowserPluginActionInternal(
         const nativeTab = nativeSession?.browser?.tab;
         const nativeBrowser = nativeSession?.browser?.provider === 'macos-apple-events'
           && nativeSession.browser.browserProduct
-          && nativeTab?.ownership === 'plugin_owned'
+          && (nativeTab?.ownership === 'plugin_owned' || nativeTab?.ownership === 'user_owned')
           && typeof nativeTab.windowId === 'string'
           && typeof nativeTab.tabId === 'string'
           ? {
@@ -4262,6 +4283,11 @@ async function executeBrowserPluginActionInternal(
               ref: { windowId: nativeTab.windowId, tabId: nativeTab.tabId },
             }
           : undefined;
+        if (input.pluginId === 'computer' && !nativeBrowser) {
+          throw new AssistantPluginError('PLUGIN_COMPUTER_NATIVE_BROWSER_HANDOFF_UNAVAILABLE',
+            'Computer handoff requires an existing bound native tab; it will not open a Playwright profile.',
+            { retryable: false });
+        }
         const handoffMode: BrowserMode = current.browserMode === 'isolated' ? 'isolated' : 'managed_persistent';
         const profile = selectedProfile(current, input.repoRoot, handoffMode, target.sessionId);
         if (!nativeBrowser) mkdirSync(profile.profileDir, { recursive: true });
@@ -4296,6 +4322,11 @@ async function executeBrowserPluginActionInternal(
       case 'get_handoff_status': {
         const interactionId = requiredString(input.args.interaction_id, 'interaction_id');
         const handoff = getBrowserHandoff(input.repoRoot, interactionId);
+        if (input.pluginId === 'computer' && !handoff.targetId.startsWith('macos-apple-events:')) {
+          throw new AssistantPluginError('PLUGIN_COMPUTER_BROWSER_PROVIDER_MISMATCH',
+            'Computer can only inspect native browser handoffs; standalone scripted handoffs are independent.',
+            { retryable: false });
+        }
         if (handoff.status === 'completed' && handoff.result?.url) {
           const session = findBrowserSession(input.repoRoot, handoff.sessionId);
           if (session) {
@@ -4323,6 +4354,11 @@ async function executeBrowserPluginActionInternal(
           throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', 'resolution must be resume or cancel', { retryable: false });
         }
         const currentHandoff = getBrowserHandoff(input.repoRoot, interactionId);
+        if (input.pluginId === 'computer' && !currentHandoff.targetId.startsWith('macos-apple-events:')) {
+          throw new AssistantPluginError('PLUGIN_COMPUTER_BROWSER_PROVIDER_MISMATCH',
+            'Computer can resolve only native browser handoffs; scripted Browser handoffs remain independent.',
+            { retryable: false });
+        }
         if (isRuntimeManagedBrowserHandoff(currentHandoff)) {
           const session = findBrowserSession(input.repoRoot, currentHandoff.sessionId);
           const managedTarget = session ? await runtimeManagedPageForSession(input.repoRoot, current, session) : undefined;
@@ -5223,30 +5259,7 @@ async function executeBrowserPluginActionInternal(
         if (requested.length === 0 || requested.length > 32) {
           throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', 'attach_local_file requires file_path or 1-32 file_paths.', { retryable: false });
         }
-        const repositoryLexicalRoot = resolve(input.repoRoot);
-        const repositoryRoot = realpathSync(input.repoRoot);
-        const resolved = requested.map((filePath) => {
-          const lexicalPath = resolve(input.repoRoot, filePath);
-          const lexicalRelative = relative(repositoryLexicalRoot, lexicalPath);
-          if (lexicalRelative === '..' || lexicalRelative.startsWith(`..${sep}`) || isAbsolute(lexicalRelative)) {
-            throw new AssistantPluginError('PLUGIN_POLICY_BLOCKED', 'Local file attachments must stay inside the repository root.', { retryable: false, details: { fileName: basename(filePath) } });
-          }
-          if (!existsSync(lexicalPath)) {
-            throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', `Local attachment does not exist: ${basename(lexicalPath)}`, { retryable: false });
-          }
-          const realPath = realpathSync(lexicalPath);
-          const repositoryRelative = relative(repositoryRoot, realPath);
-          if (repositoryRelative === '..' || repositoryRelative.startsWith(`..${sep}`) || isAbsolute(repositoryRelative)) {
-            throw new AssistantPluginError('PLUGIN_POLICY_BLOCKED', 'Local file attachments must resolve inside the repository root.', { retryable: false, details: { fileName: basename(lexicalPath) } });
-          }
-          if (!statSync(realPath).isFile()) {
-            throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', `Local attachment is not a regular file: ${basename(lexicalPath)}`, { retryable: false });
-          }
-          if (/\.(exe|dmg|pkg|sh|bat|cmd|app)$/i.test(realPath)) {
-            throw new AssistantPluginError('PLUGIN_POLICY_BLOCKED', 'Executable file attachments are not allowed.', { retryable: false });
-          }
-          return lexicalPath;
-        });
+        const resolved = resolveBrowserAttachmentPaths(input, requested, stringValue(input.args.target_key));
         return await withPage(input.actionId, input.repoRoot, current, target, input.args, async (page, _diagnostics, connection) => {
           await page.evaluate((payload) => {
             const args = payload as { selector: string; count: number };
@@ -5352,6 +5365,61 @@ async function executeBrowserPluginActionInternal(
   }
 }
 
+/** Resolve one upload batch under the repository or the existing local-system target grant.
+ * A target_key changes the path base; it never grants arbitrary absolute filesystem access.
+ */
+export function resolveBrowserAttachmentPaths(
+  input: AssistantPluginActionExecutionInput,
+  requested: string[],
+  targetKey?: string,
+): string[] {
+  const repositoryLexicalRoot = resolve(input.repoRoot);
+  const repositoryRoot = realpathSync(input.repoRoot);
+  return requested.map((filePath) => {
+    let allowedPath: string;
+    if (targetKey) {
+      try {
+        allowedPath = resolveWorkspaceTargetPath(input.controllerHome, targetKey, filePath, {
+          mustExist: true,
+          kind: 'file',
+          operation: 'read',
+          ownerScope: pluginCapabilityAuthorizationOwnerScope(input.origin),
+        }).path;
+      } catch (error) {
+        if (!(error instanceof WorkspaceTargetGrantError)) throw error;
+        throw new AssistantPluginError('PLUGIN_POLICY_BLOCKED',
+          'Upload file is not within an active, caller-owned local-system target grant.',
+          { retryable: false, details: { fileName: basename(filePath), targetKey, causeCode: error.code } });
+      }
+    } else {
+      const lexicalPath = resolve(input.repoRoot, filePath);
+      const lexicalRelative = relative(repositoryLexicalRoot, lexicalPath);
+      if (lexicalRelative === '..' || lexicalRelative.startsWith(`..${sep}`) || isAbsolute(lexicalRelative)) {
+        throw new AssistantPluginError('PLUGIN_POLICY_BLOCKED', 'Local file attachments must stay inside the repository root.', {
+          retryable: false, details: { fileName: basename(filePath) },
+        });
+      }
+      if (!existsSync(lexicalPath)) {
+        throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', `Local attachment does not exist: ${basename(lexicalPath)}`, { retryable: false });
+      }
+      allowedPath = realpathSync(lexicalPath);
+      const repositoryRelative = relative(repositoryRoot, allowedPath);
+      if (repositoryRelative === '..' || repositoryRelative.startsWith(`..${sep}`) || isAbsolute(repositoryRelative)) {
+        throw new AssistantPluginError('PLUGIN_POLICY_BLOCKED', 'Local file attachments must resolve inside the repository root.', {
+          retryable: false, details: { fileName: basename(lexicalPath) },
+        });
+      }
+    }
+    if (!statSync(allowedPath).isFile()) {
+      throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', `Local attachment is not a regular file: ${basename(filePath)}`, { retryable: false });
+    }
+    if (/\.(exe|dmg|pkg|sh|bat|cmd|app)$/i.test(allowedPath)) {
+      throw new AssistantPluginError('PLUGIN_POLICY_BLOCKED', 'Executable file attachments are not allowed.', { retryable: false });
+    }
+    return allowedPath;
+  });
+}
+
 export async function executeBrowserPluginAction(input: AssistantPluginActionExecutionInput): Promise<Record<string, unknown>> {
   return await withBrowserSessionAuthorityContext(
     { controllerHome: input.controllerHome, repoId: input.repoId },