@moretea-labs/forge 1.7.2 → 1.8.1

package/src/runtime/plugins/browser-manifest-surface.ts

@@ -7,8 +7,8 @@ import type {
 import {
   DEFAULT_BROWSER_SESSION_LIST_LIMIT,
   MAX_BROWSER_SESSION_LIST_LIMIT,
-} from './browser-session-authority';
-import { MAX_BROWSER_CDP_ENDPOINT_CANDIDATES } from './browser-runtime-contract';
+} from '../../../packages/plugin-runtime/browser/session-authority';
+import { MAX_BROWSER_CDP_ENDPOINT_CANDIDATES } from '../../../packages/plugin-runtime/browser/runtime-contract';
 
 export function browserPermissions(ready: boolean): AssistantPluginPermissionScope[] {
   return [
@@ -33,6 +33,13 @@ export function browserPermissions(ready: boolean): AssistantPluginPermissionSco
       granted: ready,
       required: true,
     },
+    {
+      scope: 'browser.extensions',
+      mode: 'write',
+      description: 'List or load bounded unpacked extensions through the existing Browser provider control plane.',
+      granted: ready,
+      required: false,
+    },
   ];
 }
 
@@ -59,11 +66,18 @@ export function browserCapabilities(): AssistantPluginCapability[] {
       scopes: ['browser.read', 'browser.profile'],
       actions: [
         'open_page', 'navigate', 'reload', 'go_back', 'wait_for_load_state',
-        'get_text', 'get_html', 'query_selector', 'query_all', 'get_attribute', 'list_frames', 'verify_state',
+        'get_text', 'get_html', 'query_selector', 'query_all', 'get_attribute', 'list_frames', 'verify_state', 'reconcile_effect',
         'screenshot', 'extract_links', 'extract_tables', 'extract_forms', 'snapshot_interactive',
         'get_console_errors', 'get_failed_requests',
       ],
     },
+    {
+      capabilityId: 'browser-extensions',
+      title: 'Browser Extensions',
+      description: 'List or load unpacked extensions from policy-bounded local directories without exposing raw CDP methods.',
+      scopes: ['browser.extensions', 'browser.profile'],
+      actions: ['list_unpacked_extensions', 'install_unpacked_extension'],
+    },
     {
       capabilityId: 'browser-interaction',
       title: 'Browser Interaction',
@@ -104,7 +118,7 @@ const frameScopeProperties = {
 
 function interactSchema(extra: Record<string, unknown>, required: string[]): Record<string, unknown> {
   return sessionTargetSchema({
-    post_action_wait_ms: { type: 'number' },
+    post_action_wait_ms: { type: 'number', minimum: 0, description: 'Optional explicit compatibility settle delay after a semantic action. Omit for normal provider completion; native foreground activation retains its provider-specific verification budget.' },
     ...extra,
   }, required);
 }
@@ -112,11 +126,11 @@ function interactSchema(extra: Record<string, unknown>, required: string[]): Rec
 export function browserActions(): AssistantPluginActionDescriptor[] {
   const readRemote = [
     { resource: 'remote' as const, mode: 'read' as const },
-    { resource: 'repo-state' as const, mode: 'write' as const },
+    { resource: 'provider-state' as const, mode: 'write' as const },
   ];
   const writeRemote = [
     { resource: 'remote' as const, mode: 'exclusive' as const },
-    { resource: 'repo-state' as const, mode: 'write' as const },
+    { resource: 'provider-state' as const, mode: 'write' as const },
   ];
   const descriptors: AssistantPluginActionDescriptor[] = [
     {
@@ -130,7 +144,7 @@ export function browserActions(): AssistantPluginActionDescriptor[] {
       cancellable: true,
       idempotent: true,
       scopes: ['browser.profile'],
-      resourceClaims: [{ resource: 'repo-state', mode: 'write' }],
+      resourceClaims: [{ resource: 'provider-state', mode: 'write' }],
       argumentsSchema: {
         type: 'object',
         properties: {
@@ -158,12 +172,31 @@ export function browserActions(): AssistantPluginActionDescriptor[] {
         additionalProperties: false,
       },
     },
+    {
+      actionId: 'list_unpacked_extensions',
+      title: 'List unpacked browser extensions',
+      description: 'List unpacked extensions visible to the selected Browser provider. No arbitrary CDP method is accepted.',
+      readOnly: true, risk: 'readonly', confirmation: 'none', defaultTimeoutMs: 30_000, cancellable: true, idempotent: true,
+      scopes: ['browser.extensions', 'browser.profile'], resourceClaims: readRemote,
+      argumentsSchema: sessionTargetSchema({}, []),
+    },
+    {
+      actionId: 'install_unpacked_extension',
+      title: 'Install unpacked browser extension',
+      description: 'Load one policy-bounded unpacked extension directory through the selected Browser provider and verify its exact installed identity.',
+      readOnly: false, risk: 'remote_write', confirmation: 'authorization', defaultTimeoutMs: 30_000, cancellable: false, idempotent: false,
+      scopes: ['browser.extensions', 'browser.profile'], resourceClaims: writeRemote,
+      argumentsSchema: sessionTargetSchema({
+        extension_path: { type: 'string' },
+        enable_in_incognito: { type: 'boolean' },
+      }, ['extension_path']),
+    },
     {
       actionId: 'create_session',
       title: 'Create browser session',
       description: 'Open an HTTP(S) URL or explicitly adopt the matching frontmost native tab, then persist a reusable session id.',
       readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 60_000, cancellable: true, idempotent: false,
-      scopes: ['browser.read', 'browser.profile'], resourceClaims: [{ resource: 'repo-state', mode: 'write' }, ...readRemote],
+      scopes: ['browser.read', 'browser.profile'], resourceClaims: readRemote,
       argumentsSchema: sessionTargetSchema({
         extract_text: { type: 'boolean' },
         max_chars: { type: 'number' },
@@ -178,7 +211,7 @@ export function browserActions(): AssistantPluginActionDescriptor[] {
       title: 'List browser sessions',
       description: 'List saved browser session metadata without secrets or cookies.',
       readOnly: true, risk: 'readonly', confirmation: 'none', defaultTimeoutMs: 10_000, cancellable: true, idempotent: true,
-      scopes: ['browser.read', 'browser.profile'], resourceClaims: [{ resource: 'repo-state', mode: 'read' }],
+      scopes: ['browser.read', 'browser.profile'], resourceClaims: [{ resource: 'provider-state', mode: 'read' }],
       argumentsSchema: {
         type: 'object',
         properties: {
@@ -193,7 +226,7 @@ export function browserActions(): AssistantPluginActionDescriptor[] {
       title: 'Reconcile browser sessions',
       description: 'Prune only saved managed-session metadata whose exact Runtime-bound page is positively proven gone. Never removes profiles, cookies, or unverified native sessions.',
       readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 15_000, cancellable: true, idempotent: true,
-      scopes: ['browser.read', 'browser.profile'], resourceClaims: [{ resource: 'repo-state', mode: 'write' }],
+      scopes: ['browser.read', 'browser.profile'], resourceClaims: [{ resource: 'provider-state', mode: 'write' }],
       argumentsSchema: { type: 'object', properties: {}, additionalProperties: false },
     },
     {
@@ -201,7 +234,7 @@ export function browserActions(): AssistantPluginActionDescriptor[] {
       title: 'Close browser session',
       description: 'Remove one saved session metadata record.',
       readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 15_000, cancellable: true, idempotent: true,
-      scopes: ['browser.read', 'browser.profile'], resourceClaims: [{ resource: 'repo-state', mode: 'write' }],
+      scopes: ['browser.read', 'browser.profile'], resourceClaims: [{ resource: 'provider-state', mode: 'write' }],
       argumentsSchema: { type: 'object', properties: { session_id: { type: 'string' } }, required: ['session_id'], additionalProperties: false },
     },
     {
@@ -209,7 +242,7 @@ export function browserActions(): AssistantPluginActionDescriptor[] {
       title: 'Clear all browser sessions',
       description: 'Remove all saved session metadata while keeping the profile.',
       readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 15_000, cancellable: true, idempotent: true,
-      scopes: ['browser.profile'], resourceClaims: [{ resource: 'repo-state', mode: 'write' }],
+      scopes: ['browser.profile'], resourceClaims: [{ resource: 'provider-state', mode: 'write' }],
       argumentsSchema: { type: 'object', properties: {}, additionalProperties: false },
     },
     {
@@ -229,7 +262,7 @@ export function browserActions(): AssistantPluginActionDescriptor[] {
       title: 'Get browser handoff status',
       description: 'Read durable browser handoff status and reconcile a stale or crashed host.',
       readOnly: true, risk: 'readonly', confirmation: 'none', defaultTimeoutMs: 10_000, cancellable: true, idempotent: true,
-      scopes: ['browser.read', 'browser.profile'], resourceClaims: [{ resource: 'repo-state', mode: 'read' }],
+      scopes: ['browser.read', 'browser.profile'], resourceClaims: [{ resource: 'provider-state', mode: 'read' }],
       argumentsSchema: { type: 'object', properties: { interaction_id: { type: 'string' } }, required: ['interaction_id'], additionalProperties: false },
     },
     {
@@ -237,7 +270,7 @@ export function browserActions(): AssistantPluginActionDescriptor[] {
       title: 'Resolve browser handoff',
       description: 'Resume or cancel a foreground browser handoff.',
       readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 15_000, cancellable: true, idempotent: true,
-      scopes: ['browser.read', 'browser.profile'], resourceClaims: [{ resource: 'repo-state', mode: 'write' }],
+      scopes: ['browser.read', 'browser.profile'], resourceClaims: [{ resource: 'provider-state', mode: 'write' }],
       argumentsSchema: {
         type: 'object',
         properties: {
@@ -318,7 +351,7 @@ export function browserActions(): AssistantPluginActionDescriptor[] {
       description: 'Return matching element summaries (bounded).',
       readOnly: true, risk: 'readonly', confirmation: 'none', defaultTimeoutMs: 60_000, cancellable: true, idempotent: true,
       scopes: ['browser.read'], resourceClaims: [{ resource: 'remote', mode: 'read' }],
-      argumentsSchema: sessionTargetSchema({ selector: { type: 'string' }, limit: { type: 'number' }, ...frameScopeProperties }, ['selector']),
+      argumentsSchema: sessionTargetSchema({ selector: { type: 'string' }, limit: { type: 'number' }, from_end: { type: 'boolean' }, ...frameScopeProperties }, ['selector']),
     },
     {
       actionId: 'get_attribute',
@@ -345,13 +378,37 @@ export function browserActions(): AssistantPluginActionDescriptor[] {
       argumentsSchema: sessionTargetSchema({
         expected_url: { type: 'string' },
         url_contains: { type: 'string' },
+        url_contains_any: { type: 'array', minItems: 1, maxItems: 16, items: { type: 'string', maxLength: 2000 } },
+        url_contains_none: { type: 'array', minItems: 1, maxItems: 16, items: { type: 'string', maxLength: 2000 } },
         selector: { type: 'string' },
         require_visible: { type: 'boolean' },
         text_contains: { type: 'string', maxLength: 10000 },
+        text_contains_any: { type: 'array', minItems: 1, maxItems: 16, items: { type: 'string', maxLength: 10000 } },
+        text_contains_none: { type: 'array', minItems: 1, maxItems: 16, items: { type: 'string', maxLength: 10000 } },
         max_chars: { type: 'number', minimum: 1, maximum: 100000 },
         ...frameScopeProperties,
       }, ['session_id']),
     },
+    {
+      actionId: 'reconcile_effect',
+      title: 'Reconcile browser effect',
+      description: 'Read the already-bound browser session and classify one exact prior effect request as applied, not_applied, or unknown from declared observation criteria. Never navigates or replays the effect.',
+      readOnly: true, risk: 'readonly', confirmation: 'none', defaultTimeoutMs: 60_000, cancellable: true, idempotent: true,
+      scopes: ['browser.read'], resourceClaims: [{ resource: 'remote', mode: 'read' }],
+      argumentsSchema: sessionTargetSchema({
+        effect_request_id: { type: 'string' },
+        applied_url_contains_any: { type: 'array', minItems: 1, maxItems: 16, items: { type: 'string', maxLength: 2000 } },
+        applied_url_contains_none: { type: 'array', minItems: 1, maxItems: 16, items: { type: 'string', maxLength: 2000 } },
+        applied_text_contains_any: { type: 'array', minItems: 1, maxItems: 16, items: { type: 'string', maxLength: 10000 } },
+        applied_text_contains_none: { type: 'array', minItems: 1, maxItems: 16, items: { type: 'string', maxLength: 10000 } },
+        applied_selector: { type: 'string' },
+        not_applied_url_contains_any: { type: 'array', minItems: 1, maxItems: 16, items: { type: 'string', maxLength: 2000 } },
+        not_applied_text_contains_any: { type: 'array', minItems: 1, maxItems: 16, items: { type: 'string', maxLength: 10000 } },
+        not_applied_selector: { type: 'string' },
+        max_chars: { type: 'number', minimum: 1, maximum: 100000 },
+        ...frameScopeProperties,
+      }, ['session_id', 'effect_request_id']),
+    },
     {
       actionId: 'screenshot',
       title: 'Screenshot',
@@ -515,7 +572,7 @@ export function browserActions(): AssistantPluginActionDescriptor[] {
     {
       actionId: 'trusted_input',
       title: 'Trusted browser input',
-      description: 'Send bounded mouse, wheel, drag, key, or text input after authorization. Playwright/CDP uses page input primitives; native macOS sessions require the exact saved tab to already be foreground/active and use the stable Desktop Operator input broker without activating another tab.',
+      description: 'Send bounded mouse, wheel, drag, key, or text input after authorization. Playwright/CDP uses page input primitives; native sessions require the exact saved tab to already be foreground/active and use the configured Computer input provider without activating another tab.',
       readOnly: false, risk: 'remote_write', confirmation: 'authorization', defaultTimeoutMs: 60_000, cancellable: true, idempotent: false,
       scopes: ['browser.interact', 'browser.profile'], resourceClaims: writeRemote,
       argumentsSchema: interactSchema({
@@ -581,7 +638,7 @@ export function browserActions(): AssistantPluginActionDescriptor[] {
       title: 'Close session',
       description: 'Remove saved session metadata while keeping the persistent profile.',
       readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 15_000, cancellable: true, idempotent: true,
-      scopes: ['browser.read', 'browser.profile'], resourceClaims: [{ resource: 'repo-state', mode: 'write' }],
+      scopes: ['browser.read', 'browser.profile'], resourceClaims: [{ resource: 'provider-state', mode: 'write' }],
       argumentsSchema: { type: 'object', properties: { session_id: { type: 'string' } }, required: ['session_id'], additionalProperties: false },
     },
   ];
@@ -594,6 +651,7 @@ export function browserActions(): AssistantPluginActionDescriptor[] {
   ]);
   return descriptors.map((descriptor) => ({
     ...descriptor,
+    executionMode: 'runtime',
     foregroundEffect: foregroundRequired.has(descriptor.actionId)
       ? 'required'
       : foregroundPossible.has(descriptor.actionId)

package/src/runtime/plugins/browser-native-session-service.ts

@@ -1,13 +1,13 @@
 import { AssistantPluginError } from './errors';
 import {
-  closeMacOsBrowserOwnedTab,
+  closeResolvedMacOsBrowserOwnedTab,
   listMacOsBrowserTabs,
   macOsBrowserPageHandleStale,
-  readMacOsBrowserOwnedTabMetadata,
+  readResolvedMacOsBrowserOwnedTabMetadata,
   type MacOsBrowserProduct,
 } from './browser-macos-bridge';
 import { listSavedBrowserSessions, removeBrowserSession } from './browser-session-store';
-import type { BrowserSessionInventoryItem, BrowserSessionState } from './browser-session-types';
+import type { BrowserSessionInventoryItem, BrowserSessionState } from '../../../packages/protocols/browser/index';
 
 export interface NativeOwnedSessionInspection {
   items: Map<string, BrowserSessionInventoryItem>;
@@ -19,12 +19,22 @@ export interface NativeOwnedSessionInspection {
   failedCleanupCount: number;
 }
 
+const MAX_NATIVE_INVENTORY_TIMEOUT_MS = 3_000;
+
+function nativeInventoryTimeoutMs(timeoutMs: number): number {
+  return Math.max(1, Math.min(timeoutMs, MAX_NATIVE_INVENTORY_TIMEOUT_MS));
+}
+
 export function nativeTabInventoryUnsupported(error: unknown): boolean {
   if (error instanceof AssistantPluginError && error.code === 'BROWSER_AUTOMATION_ACTION_UNSUPPORTED') return true;
   const message = error instanceof Error ? error.message : String(error ?? '');
   return /\bBROWSER_AUTOMATION_ACTION_UNSUPPORTED\b/.test(message);
 }
 
+function nativeBrowserApplicationNotRunning(error: unknown): boolean {
+  return error instanceof AssistantPluginError && error.code === 'PLUGIN_BROWSER_NATIVE_APP_NOT_RUNNING';
+}
+
 function isDiscardableNativeOwnedTabUrl(url: string): boolean {
   const normalized = url.trim().toLowerCase();
   return normalized === ''
@@ -35,6 +45,20 @@ function isDiscardableNativeOwnedTabUrl(url: string): boolean {
     || normalized === 'vivaldi://startpage/';
 }
 
+/**
+ * Native tab ids are only stable while the browser keeps the same tab alive.
+ * If a later inventory resolves that id to a different URL, the saved binding
+ * no longer proves ownership of that live tab. Treat the session as detached;
+ * never close the replacement tab merely because it inherited an old id.
+ */
+function nativeTabMatchesSessionUrl(session: BrowserSessionState, url: string): boolean {
+  try {
+    return new URL(session.url).toString() === new URL(url).toString();
+  } catch {
+    return session.url.trim() === url.trim();
+  }
+}
+
 /**
  * Native tab liveness/cleanup belongs to one service so the Browser adapter does
  * not reinterpret stable native identity or prune policy action-by-action.
@@ -75,13 +99,26 @@ export async function inspectNativeOwnedSessions(input: {
     let inventory = inventories.get(product);
     if (!inventory) {
       try {
-        inventory = await listMacOsBrowserTabs(product, timeoutMs);
+        inventory = await listMacOsBrowserTabs(product, nativeInventoryTimeoutMs(timeoutMs));
       } catch (error) {
         inventory = error instanceof Error ? error : new Error(String(error));
       }
       inventories.set(product, inventory);
     }
     if (inventory instanceof Error) {
+      // A plugin-owned tab cannot outlive its native browser process. This is
+      // stronger than an unavailable inventory: retire the stale transport
+      // metadata so a later continuation opens a fresh effect-scoped tab.
+      if (nativeBrowserApplicationNotRunning(inventory)) {
+        const pruned = input.pruneDead === true;
+        if (pruned) {
+          for (const session of group) removeBrowserSession(repoRoot, session.sessionId);
+          prunedCount += group.length;
+        }
+        for (const session of group) items.set(session.sessionId, { session, liveness: 'dead', evidence: 'native_tab_missing', pruned });
+        deadCount += group.length;
+        continue;
+      }
       if (!nativeTabInventoryUnsupported(inventory)) {
         for (const session of group) items.set(session.sessionId, { session, liveness: 'unverified', evidence: 'native_inventory_unavailable', cleanupError: inventory.message });
         unverifiedCount += group.length;
@@ -89,9 +126,9 @@ export async function inspectNativeOwnedSessions(input: {
       }
 
       const ref = { windowId: tab.windowId!, tabId: tab.tabId! };
-      let metadata: Awaited<ReturnType<typeof readMacOsBrowserOwnedTabMetadata>>;
+      let metadata: Awaited<ReturnType<typeof readResolvedMacOsBrowserOwnedTabMetadata>>;
       try {
-        metadata = await readMacOsBrowserOwnedTabMetadata(product, ref, timeoutMs);
+        metadata = await readResolvedMacOsBrowserOwnedTabMetadata(product, ref, timeoutMs);
       } catch (metadataError) {
         if (macOsBrowserPageHandleStale(metadataError)) {
           const pruned = input.pruneDead === true;
@@ -113,7 +150,7 @@ export async function inspectNativeOwnedSessions(input: {
         deadCount += group.length;
         if (input.pruneDead === true) {
           try {
-            await closeMacOsBrowserOwnedTab(product, ref, timeoutMs);
+            await closeResolvedMacOsBrowserOwnedTab(product, ref, timeoutMs);
             for (const session of group) removeBrowserSession(repoRoot, session.sessionId);
             prunedCount += group.length;
             closedInvalidCount += 1;
@@ -134,7 +171,7 @@ export async function inspectNativeOwnedSessions(input: {
     }
 
     const live = inventory.tabs.find((entry) => entry.windowId === tab.windowId && entry.tabId === tab.tabId);
-    if (!live) {
+    if (!live || !nativeTabMatchesSessionUrl(canonical, live.url)) {
       const pruned = input.pruneDead === true;
       if (pruned) {
         for (const session of group) removeBrowserSession(repoRoot, session.sessionId);
@@ -149,7 +186,11 @@ export async function inspectNativeOwnedSessions(input: {
       deadCount += group.length;
       if (input.pruneDead === true) {
         try {
-          await closeMacOsBrowserOwnedTab(product, { windowId: tab.windowId!, tabId: tab.tabId! }, timeoutMs);
+          await closeResolvedMacOsBrowserOwnedTab(
+            product,
+            { windowId: live.windowId, tabId: live.tabId },
+            timeoutMs,
+          );
           for (const session of group) removeBrowserSession(repoRoot, session.sessionId);
           prunedCount += group.length;
           closedInvalidCount += 1;
@@ -189,20 +230,29 @@ export async function closeTrackedNativeOwnedSession(
   const ref = { windowId: tab.windowId, tabId: tab.tabId };
   let inventory: Awaited<ReturnType<typeof listMacOsBrowserTabs>> | undefined;
   try {
-    inventory = await listMacOsBrowserTabs(browser.browserProduct, timeoutMs);
+    inventory = await listMacOsBrowserTabs(browser.browserProduct, nativeInventoryTimeoutMs(timeoutMs));
   } catch (error) {
+    if (nativeBrowserApplicationNotRunning(error)) return { resourceClosed: false, resourceAlreadyMissing: true };
     if (!nativeTabInventoryUnsupported(error)) throw error;
     try {
-      await readMacOsBrowserOwnedTabMetadata(browser.browserProduct, ref, timeoutMs);
+      await readResolvedMacOsBrowserOwnedTabMetadata(browser.browserProduct, ref, timeoutMs);
     } catch (metadataError) {
       if (macOsBrowserPageHandleStale(metadataError)) return { resourceClosed: false, resourceAlreadyMissing: true };
       throw metadataError;
     }
   }
-  if (inventory && !inventory.tabs.some((entry) => entry.windowId === tab.windowId && entry.tabId === tab.tabId)) {
-    return { resourceClosed: false, resourceAlreadyMissing: true };
+  if (inventory) {
+    const live = inventory.tabs.find((entry) => entry.windowId === tab.windowId && entry.tabId === tab.tabId);
+    if (!live) return { resourceClosed: false, resourceAlreadyMissing: true };
+    if (!nativeTabMatchesSessionUrl(session, live.url)) return { resourceClosed: false, resourceAlreadyMissing: true };
+    await closeResolvedMacOsBrowserOwnedTab(
+      browser.browserProduct,
+      { windowId: live.windowId, tabId: live.tabId },
+      timeoutMs,
+    );
+    return { resourceClosed: true, resourceAlreadyMissing: false };
   }
-  await closeMacOsBrowserOwnedTab(browser.browserProduct, ref, timeoutMs);
+  await closeResolvedMacOsBrowserOwnedTab(browser.browserProduct, ref, timeoutMs);
   return { resourceClosed: true, resourceAlreadyMissing: false };
 }
 

package/src/runtime/plugins/browser-provider-registry.ts

@@ -1,109 +1,2 @@
-import { AssistantPluginError } from './errors';
-import {
-  providerSupports,
-  type BrowserForegroundRequirement,
-  type BrowserProviderCapabilities,
-  type BrowserProviderCapability,
-} from './browser-runtime-contract';
-
-export interface BrowserRuntimeProvider<TInput, TResult> extends BrowserProviderCapabilities {
-  /** Lower values are preferred when multiple providers satisfy the same capability contract. */
-  priority: number;
-  /** Availability is decided before execution; ordinary provider failures are never fallback signals. */
-  supportsInput(input: TInput): boolean;
-  execute(input: TInput): Promise<TResult>;
-  /** Runs only after an explicit stale/restart/configuration boundary. */
-  revalidate?: () => Promise<void> | void;
-}
-
-interface BrowserProviderState<TInput, TResult> {
-  provider: BrowserRuntimeProvider<TInput, TResult>;
-  generation: number;
-  invalidatedReason?: string;
-}
-
-export interface BrowserProviderSelection<TInput, TResult> {
-  provider: BrowserRuntimeProvider<TInput, TResult>;
-  generation: number;
-}
-
-/**
- * A typed pre-action rejection. Runtime may select another provider because this proves the action
- * was not attempted. Arbitrary provider errors are intentionally not mapped to this signal.
- */
-export class BrowserProviderUnavailableBeforeActionError extends Error {
-  readonly providerId: string;
-  readonly reason: string;
-
-  constructor(providerId: string, reason: string) {
-    super(`${providerId} unavailable before action: ${reason}`);
-    this.name = 'BrowserProviderUnavailableBeforeActionError';
-    this.providerId = providerId;
-    this.reason = reason;
-  }
-}
-
-function foregroundCompatible(
-  provider: BrowserProviderCapabilities,
-  requested: BrowserForegroundRequirement,
-): boolean {
-  // Background-safe providers may execute explicit foreground transactions; foreground-only
-  // providers may not satisfy a background-safe transaction.
-  return requested === 'explicit_required' || provider.foreground === 'none';
-}
-
-export class BrowserProviderRegistry<TInput, TResult> {
-  private readonly providers = new Map<string, BrowserProviderState<TInput, TResult>>();
-
-  register(provider: BrowserRuntimeProvider<TInput, TResult>): void {
-    const current = this.providers.get(provider.providerId);
-    if (current) {
-      // Refresh call-local closures without discarding the warm provider generation.
-      current.provider = provider;
-      return;
-    }
-    this.providers.set(provider.providerId, { provider, generation: 1 });
-  }
-
-  invalidate(providerId: string, reason: string): void {
-    const state = this.providers.get(providerId);
-    if (state) state.invalidatedReason = reason;
-  }
-
-  invalidateAll(reason: string): void {
-    for (const state of this.providers.values()) state.invalidatedReason = reason;
-  }
-
-  private async prepare(state: BrowserProviderState<TInput, TResult>): Promise<void> {
-    if (!state.invalidatedReason) return;
-    await state.provider.revalidate?.();
-    state.invalidatedReason = undefined;
-    state.generation += 1;
-  }
-
-  async select(options: {
-    input: TInput;
-    requiredCapabilities: readonly BrowserProviderCapability[];
-    foreground: BrowserForegroundRequirement;
-    excludedProviderIds?: ReadonlySet<string>;
-  }): Promise<BrowserProviderSelection<TInput, TResult>> {
-    const candidates = [...this.providers.values()]
-      .filter(({ provider }) => !options.excludedProviderIds?.has(provider.providerId))
-      .filter(({ provider }) => provider.supportsInput(options.input))
-      .filter(({ provider }) => providerSupports(provider, options.requiredCapabilities))
-      .filter(({ provider }) => foregroundCompatible(provider, options.foreground))
-      .sort((left, right) => left.provider.priority - right.provider.priority
-        || left.provider.providerId.localeCompare(right.provider.providerId));
-
-    const selected = candidates[0];
-    if (!selected) {
-      throw new AssistantPluginError(
-        'PLUGIN_BROWSER_PROVIDER_UNAVAILABLE',
-        `No Browser provider satisfies required capabilities: ${options.requiredCapabilities.join(', ') || 'browser.transaction'}.`,
-        { retryable: true },
-      );
-    }
-    await this.prepare(selected);
-    return { provider: selected.provider, generation: selected.generation };
-  }
-}
+/** @deprecated C0 compatibility shim. Browser provider selection lives in packages/plugin-runtime/browser. */
+export * from '../../../packages/plugin-runtime/browser/provider-registry';

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

@@ -0,0 +1,32 @@
+import {
+  buildBrowserPluginManifest,
+  executeBrowserPluginAction,
+  resolveBrowserPluginAuthorizationContext,
+} from './browser-adapter';
+import type { AssistantPluginAdapter } from './types';
+
+/** Browser manifests derive from config plus saved-session and active-handoff authority. */
+const BROWSER_MANIFEST_MUTATING_ACTIONS = new Set([
+  'configure',
+  'reconcile_sessions',
+  'close_session',
+  'close_page',
+  'clear_session',
+  'request_human_handoff',
+  'resolve_handoff',
+  'create_session',
+  'open_page',
+]);
+
+/** Thin first-party registration. Browser execution remains an adapter implementation detail. */
+export const browserPluginAdapter: AssistantPluginAdapter = {
+  pluginId: 'browser',
+  scope: 'controller_with_repository_overlay',
+  exposure: 'internal',
+  buildManifest: buildBrowserPluginManifest,
+  executeAction: executeBrowserPluginAction,
+  resolveAuthorizationContext: resolveBrowserPluginAuthorizationContext,
+  shouldRefreshManifestAfterAction(actionId) {
+    return BROWSER_MANIFEST_MUTATING_ACTIONS.has(actionId);
+  },
+};