@moretea-labs/forge 1.7.1 → 1.8.0

package/src/runtime/plugins/desktop-operator-registration.ts

@@ -1,3 +1,11 @@
+import {
+  COMPUTER_CAPTURE_CAPABILITY,
+  COMPUTER_CONSOLE_UNLOCK_CAPABILITY,
+  COMPUTER_ELEMENT_ACTION_CAPABILITY,
+  COMPUTER_ELEMENT_OBSERVE_CAPABILITY,
+  COMPUTER_INPUT_CAPABILITY,
+  COMPUTER_OBSERVE_CAPABILITY,
+} from '../../../packages/protocols/computer/index';
 import type { ExternalPluginRegistrationInput } from './external-registration';
 import type { AssistantPluginActionDescriptor } from './types';
 
@@ -19,7 +27,7 @@ const SELECTOR_SCHEMA = {
   additionalProperties: false,
 };
 
-function desktopOperatorActions(): AssistantPluginActionDescriptor[] {
+export function desktopOperatorActions(): AssistantPluginActionDescriptor[] {
   return [
     {
       actionId: 'desktop_status',
@@ -143,6 +151,94 @@ function desktopOperatorActions(): AssistantPluginActionDescriptor[] {
         additionalProperties: false,
       },
     },
+    {
+      actionId: 'desktop_select_rows',
+      title: 'Select desktop rows',
+      description: 'Select one bounded contiguous row range in a semantic Accessibility list or table. Selection stays inside the bound desktop session and does not activate the application or use coordinates.',
+      readOnly: false,
+      risk: 'workspace_write',
+      confirmation: 'authorization',
+      defaultTimeoutMs: 10_000,
+      cancellable: true,
+      idempotent: false,
+      scopes: ['desktop.interact'],
+      resourceClaims: CONTROLLER_WRITE,
+      argumentsSchema: {
+        type: 'object',
+        properties: {
+          interaction_id: { type: 'string' },
+          selector: SELECTOR_SCHEMA,
+          start_index: { type: 'integer', minimum: 0 },
+          end_index: { type: 'integer', minimum: 0 },
+        },
+        required: ['interaction_id', 'selector', 'start_index'],
+        additionalProperties: false,
+      },
+    },
+    {
+      actionId: 'desktop_pointer_click',
+      title: 'Click observed desktop element',
+      description: 'Click one previously observed Accessibility element by ref inside an exact observed window. Forge re-resolves the ref, fences it to the source window, rebinds it after verified application activation, derives fresh bounded geometry and visual revision internally, and fails closed on stale refs/windows; raw coordinates are never accepted.',
+      readOnly: false,
+      risk: 'workspace_write',
+      confirmation: 'authorization',
+      defaultTimeoutMs: 10_000,
+      cancellable: true,
+      idempotent: false,
+      scopes: ['desktop.interact', 'desktop.capture'],
+      resourceClaims: CONTROLLER_WRITE,
+      argumentsSchema: {
+        type: 'object',
+        properties: {
+          interaction_id: { type: 'string' },
+          selector: {
+            type: 'object',
+            properties: { ref: { type: 'string' } },
+            required: ['ref'],
+            additionalProperties: false,
+          },
+          window_id: { type: 'integer', minimum: 1 },
+          label: { type: 'string' },
+        },
+        required: ['interaction_id', 'selector', 'window_id'],
+        additionalProperties: false,
+      },
+    },
+    {
+      actionId: 'desktop_pointer_drag',
+      title: 'Drag observed desktop element',
+      description: 'Drag one previously observed Accessibility element to another by ref inside the same exact observed window. Forge re-resolves both refs, rebinds both after verified activation only when both have stable selectors, derives fresh bounded centers and visual revision internally, and never accepts raw coordinates.',
+      readOnly: false,
+      risk: 'workspace_write',
+      confirmation: 'authorization',
+      defaultTimeoutMs: 10_000,
+      cancellable: true,
+      idempotent: false,
+      scopes: ['desktop.interact', 'desktop.capture'],
+      resourceClaims: CONTROLLER_WRITE,
+      argumentsSchema: {
+        type: 'object',
+        properties: {
+          interaction_id: { type: 'string' },
+          source_selector: {
+            type: 'object',
+            properties: { ref: { type: 'string' } },
+            required: ['ref'],
+            additionalProperties: false,
+          },
+          target_selector: {
+            type: 'object',
+            properties: { ref: { type: 'string' } },
+            required: ['ref'],
+            additionalProperties: false,
+          },
+          window_id: { type: 'integer', minimum: 1 },
+          label: { type: 'string' },
+        },
+        required: ['interaction_id', 'source_selector', 'target_selector', 'window_id'],
+        additionalProperties: false,
+      },
+    },
     {
       actionId: 'desktop_type_text',
       title: 'Type desktop text',
@@ -170,7 +266,7 @@ function desktopOperatorActions(): AssistantPluginActionDescriptor[] {
     {
       actionId: 'desktop_key',
       title: 'Press desktop keys',
-      description: 'Send one bounded key chord to the exact target session after Forge independently re-establishes and verifies that application as system-frontmost at the action boundary.',
+      description: 'Send one bounded key chord only after Forge verifies that the exact session is already system-frontmost and that its uniquely focused Accessibility window remains the same CGWindow; Forge never reactivates the application bundle at this boundary.',
       readOnly: false,
       risk: 'workspace_write',
       confirmation: 'authorization',
@@ -244,7 +340,7 @@ function desktopOperatorActions(): AssistantPluginActionDescriptor[] {
     {
       actionId: 'desktop_paste',
       title: 'Paste into desktop session',
-      description: 'Send Command+V only when the explicit target session is already foreground; the operator never activates it.',
+      description: 'Send Command+V only after Forge verifies that the explicit target session is already system-frontmost and its exact focused window remains stable; the operator never reactivates the application bundle.',
       readOnly: false,
       risk: 'workspace_write',
       confirmation: 'authorization',
@@ -305,7 +401,7 @@ function desktopOperatorActions(): AssistantPluginActionDescriptor[] {
     {
       actionId: 'desktop_batch',
       title: 'Run desktop batch',
-      description: 'Run at most 50 non-batch Desktop Operator steps under one authorized interaction request.',
+      description: 'Run at most 50 non-batch Desktop Operator steps under one authorized interaction request; nested key/copy/paste input is exact-window verified for one foreground session and rejects conflicting activation or multi-session focus.',
       readOnly: false,
       risk: 'workspace_write',
       confirmation: 'authorization',
@@ -363,7 +459,7 @@ export interface DesktopOperatorRegistrationOptions {
   socketPath: string;
   launchAgentLabel?: string;
   expectedProgramContains?: string;
-  pluginVersion?: string;
+  pluginVersion: string;
   protocolVersion?: string;
   enabled?: boolean;
 }
@@ -387,17 +483,18 @@ export function createDesktopOperatorRegistrationInput(
     providerPluginId: 'desktop_operator',
     displayName: 'Forge Desktop Operator',
     provider: 'local-macos',
-    pluginVersion: options.pluginVersion ?? '0.2.1',
+    pluginVersion: options.pluginVersion,
     protocolVersion: options.protocolVersion ?? '1.0',
     scope: 'controller',
     enabled: options.enabled !== false,
+    exposure: 'provider',
     transport: {
       kind: 'unix_socket_jsonl',
       socketPath: options.socketPath,
       healthTimeoutMs: 2_000,
       actionTimeoutMs: 30_000,
       maxRequestBytes: 1_048_576,
-      maxResponseBytes: 1_048_576,
+      maxResponseBytes: 4 * 1_048_576,
     },
     lifecycle: options.launchAgentLabel && options.expectedProgramContains ? {
       kind: 'verified_user_launch_agent',
@@ -410,10 +507,16 @@ export function createDesktopOperatorRegistrationInput(
       { capabilityId: 'desktop.permissions', title: 'Desktop permissions', description: 'Request the official macOS permissions required by Desktop Operator capabilities.', scopes: ['desktop.permissions'], actions: ['desktop_permissions_request'] },
       { capabilityId: 'desktop.session', title: 'Desktop sessions', description: 'Create and close application interaction sessions.', scopes: ['desktop.session'], actions: ['desktop_session_open', 'desktop_session_close'] },
       { capabilityId: 'desktop.observe', title: 'Desktop observation', description: 'Read bounded Accessibility and window state.', scopes: ['desktop.observe'], actions: ['desktop_observe'] },
-      { capabilityId: 'desktop.interact', title: 'Desktop interaction', description: 'Press controls, type text, send keys, and open URLs.', scopes: ['desktop.interact'], actions: ['desktop_press', 'desktop_type_text', 'desktop_key', 'desktop_open_url'] },
+      { capabilityId: 'desktop.interact', title: 'Desktop interaction', description: 'Press controls, click previously observed controls, type text, send keys, and open URLs.', scopes: ['desktop.interact', 'desktop.capture'], actions: ['desktop_press', 'desktop_select_rows', 'desktop_pointer_click', 'desktop_pointer_drag', 'desktop_type_text', 'desktop_key', 'desktop_open_url'] },
       { capabilityId: 'desktop.capture', title: 'Desktop capture', description: 'Capture authorized screenshots.', scopes: ['desktop.capture'], actions: ['desktop_screenshot'] },
       { capabilityId: 'desktop.clipboard', title: 'Desktop clipboard', description: 'Read or replace plain-text clipboard content and issue explicit copy/paste in a bound session.', scopes: ['desktop.clipboard'], actions: ['desktop_clipboard_read', 'desktop_clipboard_write', 'desktop_copy', 'desktop_paste'] },
       { capabilityId: 'desktop.batch', title: 'Desktop batch', description: 'Run bounded desktop action batches.', scopes: ['desktop.batch'], actions: ['desktop_batch'] },
+      { capabilityId: COMPUTER_OBSERVE_CAPABILITY, title: 'Computer observation', description: 'Provider-neutral bounded computer observation implemented by Desktop Operator.', scopes: ['desktop.observe'], actions: ['desktop_observe'] },
+      { capabilityId: COMPUTER_INPUT_CAPABILITY, title: 'Computer input', description: 'Provider-neutral bounded computer input implemented by Desktop Operator.', scopes: ['desktop.interact'], actions: ['desktop_press', 'desktop_select_rows', 'desktop_type_text', 'desktop_key', 'desktop_open_url'] },
+      { capabilityId: COMPUTER_CONSOLE_UNLOCK_CAPABILITY, title: 'Protected console unlock', description: 'Provider-neutral protected console unlock. Invocation is intentionally absent from the generic Assistant Plugin action registry so credentials cannot enter durable plugin receipts.', scopes: [], actions: [] },
+      { capabilityId: COMPUTER_CAPTURE_CAPABILITY, title: 'Computer capture', description: 'Provider-neutral authorized computer capture implemented by Desktop Operator.', scopes: ['desktop.capture'], actions: ['desktop_screenshot'] },
+      { capabilityId: COMPUTER_ELEMENT_OBSERVE_CAPABILITY, title: 'Computer element observation', description: 'Provider-neutral element snapshot observation with exact observation-epoch target identity. Provider semantic actions are negotiated through the Computer handshake, not the Assistant Plugin action registry.', scopes: ['desktop.observe'], actions: [] },
+      { capabilityId: COMPUTER_ELEMENT_ACTION_CAPABILITY, title: 'Computer semantic element actions', description: 'Provider-neutral semantic actions against exact observed element targets. The provider handshake is the action-set authority.', scopes: ['desktop.interact'], actions: [] },
     ],
     actions,
     legacyIdentities: ['Repo Harness Desktop Operator'],

package/src/runtime/plugins/errors.ts

@@ -1,11 +1,15 @@
+export type AssistantPluginEffectOutcome = 'failed' | 'outcome_unknown';
+
 export interface AssistantPluginErrorOptions {
   retryable?: boolean;
+  effectOutcome?: AssistantPluginEffectOutcome;
   details?: Record<string, unknown>;
 }
 
 export class AssistantPluginError extends Error {
   readonly code: string;
   readonly retryable: boolean;
+  readonly effectOutcome: AssistantPluginEffectOutcome;
   readonly details?: Record<string, unknown>;
 
   constructor(code: string, message: string, options: AssistantPluginErrorOptions = {}) {
@@ -13,6 +17,7 @@ export class AssistantPluginError extends Error {
     this.name = 'AssistantPluginError';
     this.code = code;
     this.retryable = options.retryable === true;
+    this.effectOutcome = options.effectOutcome ?? 'failed';
     this.details = options.details;
   }
 }
@@ -23,17 +28,19 @@ export function isAssistantPluginError(error: unknown): error is AssistantPlugin
 
 export function toAssistantPluginError(
   error: unknown,
-  fallback: { code: string; message: string; retryable?: boolean; details?: Record<string, unknown> },
+  fallback: { code: string; message: string; retryable?: boolean; effectOutcome?: AssistantPluginEffectOutcome; details?: Record<string, unknown> },
 ): AssistantPluginError {
   if (isAssistantPluginError(error)) return error;
   if (error instanceof Error) {
     return new AssistantPluginError(fallback.code, error.message, {
       retryable: fallback.retryable,
+      effectOutcome: fallback.effectOutcome,
       details: fallback.details,
     });
   }
   return new AssistantPluginError(fallback.code, fallback.message, {
     retryable: fallback.retryable,
+    effectOutcome: fallback.effectOutcome,
     details: fallback.details,
   });
 }

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

@@ -1,9 +1,12 @@
-import { createHash } from 'crypto';
 import { AssistantPluginError } from './errors';
 import { getExternalPluginRegistration, listExternalPluginRegistrations, type ExternalPluginRegistration } from './external-registration';
 import { callExternalUnixSocket, probeExternalUnixSocketSync, type ExternalUnixSocketCallOptions } from './external-unix-socket';
 import { executeManagedPluginProcess, executeManagedPluginProcessSync, type ManagedPluginProcessSpec } from './managed-process-adapter';
 import { activateAndVerifyFrontmostApplication, restartVerifiedUserLaunchAgent, startVerifiedUserLaunchAgent, stopVerifiedUserLaunchAgent } from './local-system-adapter';
+import {
+  resolveExternalProviderPolicy,
+  type ExternalProviderPolicyContext,
+} from './external-provider-policy';
 import type { AssistantPluginActionDescriptor, AssistantPluginAdapter, AssistantPluginAuthorizationContext, AssistantPluginCapability, AssistantPluginHealth, AssistantPluginManifest, AssistantPluginPermissionScope } from './types';
 
 interface ProviderManifest {
@@ -61,9 +64,10 @@ function parseProviderManifest(value: Record<string, unknown>, registration: Ext
   if (manifest.protocolVersion !== registration.protocolVersion) throw providerError('EXTERNAL_PLUGIN_PROTOCOL_MISMATCH', `Expected provider protocol ${registration.protocolVersion}, received ${manifest.protocolVersion || 'unknown'}.`);
   if (manifest.scope !== registration.scope) throw providerError('EXTERNAL_PLUGIN_SCOPE_MISMATCH', `Expected provider scope ${registration.scope}, received ${manifest.scope || 'unknown'}.`);
   if (manifest.provider !== registration.provider) throw providerError('EXTERNAL_PLUGIN_PROVIDER_MISMATCH', `Expected provider ${registration.provider}, received ${manifest.provider || 'unknown'}.`);
+  const providerPolicy = resolveExternalProviderPolicy(registration);
   const missingActions = registration.actions
     .map((action) => action.actionId)
-    .filter((actionId) => !(registration.pluginId === 'desktop_operator' && ['desktop_pointer_click', 'desktop_foreground_pointer_click'].includes(actionId)))
+    .filter((actionId) => !(providerPolicy?.allowsMissingProviderAction?.(actionId) ?? false))
     .filter((actionId) => !manifest.actions.includes(actionId));
   if (missingActions.length > 0) throw providerError('EXTERNAL_PLUGIN_ACTION_MISMATCH', `Provider is missing registered actions: ${missingActions.join(', ')}.`);
   return manifest;
@@ -205,199 +209,51 @@ function externalProviderAuthorizationContext(registration: ExternalPluginRegist
   };
 }
 
-function desktopApplicationAuthorizationContext(
+async function resolveExternalAuthorizationContext(
   registration: ExternalPluginRegistration,
-  stableApplicationId: string,
-): AssistantPluginAuthorizationContext {
-  const normalized = stableApplicationId.trim();
-  return {
-    target: {
-      kind: 'desktop-application',
-      id: normalized,
-      identityFingerprint: createHash('sha256')
-        .update(`${registration.registrationFingerprint}\0${normalized}`)
-        .digest('hex'),
-    },
-    expiresInMinutes: 30 * 24 * 60,
-  };
-}
-
-function recordArray(value: unknown): Record<string, unknown>[] {
-  return Array.isArray(value)
-    ? value.filter((entry): entry is Record<string, unknown> => Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry))
-    : [];
-}
-
-function firstString(record: Record<string, unknown>, ...keys: string[]): string {
-  for (const key of keys) {
-    const value = record[key];
-    if (typeof value === 'string' && value.trim()) return value.trim();
-  }
-  return '';
-}
-
-function firstNumber(record: Record<string, unknown>, ...keys: string[]): number | undefined {
-  for (const key of keys) {
-    const value = record[key];
-    if (typeof value === 'number' && Number.isFinite(value)) return value;
-  }
-  return undefined;
-}
-
-function desktopSession(status: Record<string, unknown>, interactionId: string): Record<string, unknown> | undefined {
-  return recordArray(status.sessions).find((session) => firstString(session, 'interactionId', 'interaction_id') === interactionId);
-}
-
-async function independentlyEnsureExactFrontmostDesktopApplication(
-  bundleId: string,
-  appName: string,
+  input: Parameters<NonNullable<AssistantPluginAdapter['resolveAuthorizationContext']>>[0],
   dependencies: ExternalPluginAdapterDependencies,
-): Promise<void> {
-  const activateAndVerify = dependencies.activateAndVerifyFrontmostApplication ?? activateAndVerifyFrontmostApplication;
-  const proof = await activateAndVerify({ bundleId: bundleId || undefined, appName: appName || undefined });
-  const proofBundleId = typeof proof.bundleId === 'string' ? proof.bundleId.trim() : '';
-  const proofAppName = typeof proof.appName === 'string' ? proof.appName.trim() : '';
-  const proofMatches = bundleId ? proofBundleId === bundleId : proofAppName === appName;
-  if (proof.activated !== true || proof.verified !== true || !proofMatches) {
-    throw new AssistantPluginError(
-      'DESKTOP_ACTIVATION_FALLBACK_IDENTITY_MISMATCH',
-      `Forge did not prove the exact requested application ${bundleId || appName} as frontmost.`,
-      { retryable: true, details: { target: { bundleId, appName }, observed: { bundleId: proofBundleId, appName: proofAppName } } },
-    );
+): Promise<AssistantPluginAuthorizationContext | undefined> {
+  if (EXTERNAL_PROVIDER_LIFECYCLE_ACTIONS.has(input.actionId)) {
+    return externalProviderAuthorizationContext(registration);
   }
+  const providerPolicy = resolveExternalProviderPolicy(registration);
+  if (!providerPolicy?.resolveAuthorizationContext) return undefined;
+  return await providerPolicy.resolveAuthorizationContext(
+    registration,
+    input,
+    externalProviderPolicyContext(registration, dependencies),
+  );
 }
 
-async function openVerifiedDesktopSession(
+function externalProviderPolicyContext(
   registration: ExternalPluginRegistration,
-  requestId: string,
-  args: Record<string, unknown>,
-  timeoutMs: number | undefined,
-  signal: AbortSignal | undefined,
   dependencies: ExternalPluginAdapterDependencies,
-): Promise<Record<string, unknown>> {
-  const bundleId = typeof args.bundle_id === 'string' ? args.bundle_id.trim() : '';
-  const appName = typeof args.app_name === 'string' ? args.app_name.trim() : '';
-  if (!bundleId && !appName) {
-    throw providerError('DESKTOP_ACTIVATION_TARGET_UNAVAILABLE', 'Activated desktop sessions require an exact bundle id or application name.');
-  }
-
-  let result: Record<string, unknown>;
-  let providerActivationError: AssistantPluginError | undefined;
-  try {
-    result = await callProvider(
+): ExternalProviderPolicyContext {
+  return {
+    callProvider: (requestId, actionId, args, timeoutMs, signal) => callProvider(
       registration,
       requestId,
-      'desktop_session_open',
+      actionId,
       args,
       timeoutMs,
       signal,
       dependencies,
-    );
-  } catch (error) {
-    if (!(error instanceof AssistantPluginError) || error.code !== 'APP_ACTIVATION_FAILED') throw error;
-    providerActivationError = error;
-    result = await callProvider(
-      registration,
-      `${requestId}:fallback-session`,
-      'desktop_session_open',
-      { ...(bundleId ? { bundle_id: bundleId } : { app_name: appName }), launch: false, activate: false },
-      timeoutMs,
-      signal,
-      dependencies,
-    );
-  }
-
-  try {
-    await independentlyEnsureExactFrontmostDesktopApplication(bundleId, appName, dependencies);
-  } catch (verificationError) {
-    const wrappedCode = providerActivationError ? 'DESKTOP_ACTIVATION_FALLBACK_FAILED' : 'DESKTOP_ACTIVATION_NOT_CONFIRMED';
-    const wrappedMessage = providerActivationError
-      ? `Desktop Operator activation failed and Forge could not independently verify ${bundleId || appName} as frontmost.`
-      : `Desktop Operator returned an activated session, but Forge could not independently verify ${bundleId || appName} as frontmost.`;
-    if (verificationError instanceof AssistantPluginError) {
-      throw new AssistantPluginError(wrappedCode, wrappedMessage, {
-        retryable: verificationError.retryable,
-        details: {
-          ...(providerActivationError ? { providerErrorCode: providerActivationError.code } : {}),
-          verificationErrorCode: verificationError.code,
-          verificationErrorMessage: verificationError.message,
-          target: bundleId || appName,
-        },
-      });
-    }
-    throw new AssistantPluginError(wrappedCode, wrappedMessage, {
-      retryable: true,
-      details: {
-        ...(providerActivationError ? { providerErrorCode: providerActivationError.code } : {}),
-        verificationErrorMessage: String(verificationError),
-        target: bundleId || appName,
-      },
-    });
-  }
-
-  return result;
-}
-
-async function resolveExternalAuthorizationContext(
-  registration: ExternalPluginRegistration,
-  input: Parameters<NonNullable<AssistantPluginAdapter['resolveAuthorizationContext']>>[0],
-  dependencies: ExternalPluginAdapterDependencies,
-): Promise<AssistantPluginAuthorizationContext | undefined> {
-  if (EXTERNAL_PROVIDER_LIFECYCLE_ACTIONS.has(input.actionId)) {
-    return externalProviderAuthorizationContext(registration);
-  }
-  if (registration.pluginId !== 'desktop_operator') return undefined;
-  if (input.actionId === 'desktop_permissions_request') {
-    return externalProviderAuthorizationContext(registration);
-  }
-  if (input.actionId === 'desktop_session_open') {
-    const bundleId = typeof input.args.bundle_id === 'string' ? input.args.bundle_id.trim() : '';
-    return bundleId ? desktopApplicationAuthorizationContext(registration, bundleId) : undefined;
-  }
-
-  const interactionId = typeof input.args.interaction_id === 'string' ? input.args.interaction_id.trim() : '';
-  if (!interactionId) return undefined;
-
-  const providerManifest = await callProvider(
-    registration,
-    `${input.requestId}:authorization-target:manifest`,
-    'manifest',
-    {},
-    undefined,
-    input.signal,
-    dependencies,
-  );
-  parseProviderManifest(providerManifest, registration);
-  const status = await callProvider(
-    registration,
-    `${input.requestId}:authorization-target:desktop-status`,
-    'desktop_status',
-    { limit: 500 },
-    input.timeoutMs,
-    input.signal,
-    dependencies,
-  );
-  const sessions = Array.isArray(status.sessions) ? status.sessions : [];
-  const session = sessions.find((entry) => {
-    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return false;
-    const record = entry as Record<string, unknown>;
-    const id = typeof record.interactionId === 'string' ? record.interactionId : typeof record.interaction_id === 'string' ? record.interaction_id : '';
-    return id === interactionId;
-  }) as Record<string, unknown> | undefined;
-  if (!session) {
-    throw providerError('EXTERNAL_PLUGIN_AUTHORIZATION_TARGET_UNAVAILABLE', `Desktop session ${interactionId} was not found while resolving its stable authorization target.`, false);
-  }
-  const bundleId = typeof session.bundleIdentifier === 'string' ? session.bundleIdentifier.trim()
-    : typeof session.bundle_identifier === 'string' ? session.bundle_identifier.trim()
-      : '';
-  const appName = typeof session.appName === 'string' ? session.appName.trim()
-    : typeof session.app_name === 'string' ? session.app_name.trim()
-      : '';
-  const stableApplicationId = bundleId || (appName ? `name:${appName.toLowerCase()}` : '');
-  if (!stableApplicationId) {
-    throw providerError('EXTERNAL_PLUGIN_AUTHORIZATION_TARGET_UNAVAILABLE', `Desktop session ${interactionId} has no stable application identity.`, false);
-  }
-  return desktopApplicationAuthorizationContext(registration, stableApplicationId);
+    ),
+    verifyProviderIdentity: async (requestId, signal) => {
+      const providerManifest = await callProvider(
+        registration,
+        requestId,
+        'manifest',
+        {},
+        undefined,
+        signal,
+        dependencies,
+      );
+      parseProviderManifest(providerManifest, registration);
+    },
+    activateAndVerifyFrontmostApplication: dependencies.activateAndVerifyFrontmostApplication ?? activateAndVerifyFrontmostApplication,
+  };
 }
 
 export function getExternalPluginAdapter(controllerHome: string, pluginId: string): AssistantPluginAdapter | undefined {
@@ -422,6 +278,7 @@ export function createExternalPluginAdapter(
   return {
     pluginId: registration.pluginId,
     scope: registration.scope,
+    exposure: registration.exposure === 'provider' ? 'internal' : 'product',
     resolveAuthorizationContext: (input) => resolveExternalAuthorizationContext(registration, input, dependencies),
     buildManifest(previousRevision = 0, previousUpdatedAt?: string): AssistantPluginManifest {
       const checkedAt = now().toISOString();
@@ -517,149 +374,15 @@ export function createExternalPluginAdapter(
         );
         parseProviderManifest(providerManifest, registration);
       }
-      if (registration.pluginId === 'desktop_operator' && input.actionId === 'desktop_foreground_pointer_click') {
-        const sourceInteractionId = typeof input.args.interaction_id === 'string' ? input.args.interaction_id.trim() : '';
-        const requestedWindowId = typeof input.args.window_id === 'number' && Number.isInteger(input.args.window_id) ? input.args.window_id : undefined;
-        const x = typeof input.args.x === 'number' && Number.isFinite(input.args.x) ? input.args.x : undefined;
-        const y = typeof input.args.y === 'number' && Number.isFinite(input.args.y) ? input.args.y : undefined;
-        if (!sourceInteractionId || !requestedWindowId || x === undefined || y === undefined) {
-          throw providerError('DESKTOP_FOREGROUND_POINTER_ARGUMENT_INVALID', 'desktop_foreground_pointer_click requires interaction_id, window_id, x, and y.');
-        }
-
-        const sourceStatus = await callProvider(
-          registration,
-          `${input.requestId}:source-status`,
-          'desktop_status',
-          { limit: 500 },
-          input.timeoutMs,
-          input.signal,
-          dependencies,
-        );
-        const sourceSession = desktopSession(sourceStatus, sourceInteractionId);
-        if (!sourceSession) {
-          throw providerError('DESKTOP_FOREGROUND_POINTER_SESSION_NOT_FOUND', `Desktop session ${sourceInteractionId} is no longer available.`, true);
-        }
-        const bundleId = firstString(sourceSession, 'bundleIdentifier', 'bundle_id');
-        const appName = firstString(sourceSession, 'appName', 'app_name');
-        if (!bundleId && !appName) {
-          throw providerError('DESKTOP_FOREGROUND_POINTER_TARGET_UNAVAILABLE', `Desktop session ${sourceInteractionId} has no stable application identity.`);
-        }
-
-        const activation = await openVerifiedDesktopSession(
-          registration,
-          `${input.requestId}:activate`,
-          { ...(bundleId ? { bundle_id: bundleId } : { app_name: appName }), launch: false, activate: true },
-          input.timeoutMs,
-          input.signal,
-          dependencies,
-        );
-        const activationInteractionId = firstString(activation, 'interactionId', 'interaction_id');
-        if (!activationInteractionId) {
-          throw providerError('DESKTOP_ACTIVATION_SESSION_MISSING', 'Desktop Operator activated the application without returning a bound interaction session.', true);
-        }
-
-        const screenshot = await callProvider(
-          registration,
-          `${input.requestId}:screenshot`,
-          'desktop_screenshot',
-          {
-            interaction_id: activationInteractionId,
-            scope: 'window',
-            window_id: requestedWindowId,
-            ...(typeof input.args.label === 'string' && input.args.label.trim() ? { label: input.args.label.trim() } : {}),
-          },
-          input.timeoutMs,
-          input.signal,
-          dependencies,
-        );
-        const visualRevision = firstNumber(screenshot, 'visual_revision', 'visualRevision');
-        const capturedWindowId = firstNumber(screenshot, 'windowId', 'window_id') ?? requestedWindowId;
-        if (!visualRevision || !capturedWindowId) {
-          throw providerError('DESKTOP_FOREGROUND_CAPTURE_INVALID', 'Desktop Operator did not return a fresh visual revision for the foreground window.', true);
-        }
-
-        const click = await callProvider(
-          registration,
-          `${input.requestId}:click`,
-          'desktop_pointer_click',
-          {
-            interaction_id: activationInteractionId,
-            window_id: capturedWindowId,
-            visual_revision: visualRevision,
-            x,
-            y,
-          },
-          input.timeoutMs,
-          input.signal,
-          dependencies,
-        );
-        return {
-          interactionId: activationInteractionId,
-          activationVerified: true,
-          windowId: capturedWindowId,
-          visualRevision,
-          screenshot,
-          click,
-        };
-      }
-
-      if (registration.pluginId === 'desktop_operator' && input.actionId === 'desktop_key') {
-        const sourceInteractionId = typeof input.args.interaction_id === 'string' ? input.args.interaction_id.trim() : '';
-        const keys = Array.isArray(input.args.keys) ? input.args.keys : [];
-        if (!sourceInteractionId || keys.length === 0) {
-          throw providerError('DESKTOP_FOREGROUND_KEY_ARGUMENT_INVALID', 'desktop_key requires interaction_id and at least one key.');
-        }
-        const sourceStatus = await callProvider(
-          registration,
-          `${input.requestId}:source-status`,
-          'desktop_status',
-          { limit: 500 },
-          input.timeoutMs,
-          input.signal,
-          dependencies,
-        );
-        const sourceSession = desktopSession(sourceStatus, sourceInteractionId);
-        if (!sourceSession) {
-          throw providerError('DESKTOP_FOREGROUND_KEY_SESSION_NOT_FOUND', `Desktop session ${sourceInteractionId} is no longer available.`, true);
-        }
-        const bundleId = firstString(sourceSession, 'bundleIdentifier', 'bundle_id');
-        const appName = firstString(sourceSession, 'appName', 'app_name');
-        if (!bundleId && !appName) {
-          throw providerError('DESKTOP_FOREGROUND_KEY_TARGET_UNAVAILABLE', `Desktop session ${sourceInteractionId} has no stable application identity.`);
-        }
-        const activation = await openVerifiedDesktopSession(
-          registration,
-          `${input.requestId}:activate`,
-          { ...(bundleId ? { bundle_id: bundleId } : { app_name: appName }), launch: false, activate: true },
-          input.timeoutMs,
-          input.signal,
-          dependencies,
-        );
-        const activationInteractionId = firstString(activation, 'interactionId', 'interaction_id');
-        if (!activationInteractionId) {
-          throw providerError('DESKTOP_ACTIVATION_SESSION_MISSING', 'Desktop Operator activated the application without returning a bound interaction session.', true);
-        }
-        return await callProvider(
-          registration,
-          `${input.requestId}:key`,
-          'desktop_key',
-          { interaction_id: activationInteractionId, keys },
-          input.timeoutMs,
-          input.signal,
-          dependencies,
+      const providerPolicy = resolveExternalProviderPolicy(registration);
+      if (providerPolicy?.executeAction) {
+        const policyResult = await providerPolicy.executeAction(
+          input,
+          externalProviderPolicyContext(registration, dependencies),
         );
+        if (policyResult.handled) return policyResult.result ?? {};
       }
 
-      if (registration.pluginId === 'desktop_operator' && input.actionId === 'desktop_session_open' && input.args.activate === true) {
-        return await openVerifiedDesktopSession(
-          registration,
-          input.requestId,
-          input.args,
-          input.timeoutMs,
-          input.signal,
-          dependencies,
-        );
-      }
       return await callProvider(
         registration,
         input.requestId,