@@ -288,6 +288,10 @@
       "types": "./src/interactor-types.ts",
       "default": "./src/interactor-types.ts"
     },
+    "./unsupported-interactor": {
+      "types": "./src/unsupported-interactor.ts",
+      "default": "./src/unsupported-interactor.ts"
+    },
     "./keyboard": {
       "types": "./src/keyboard.ts",
       "default": "./src/keyboard.ts"
 
@@ -0,0 +1,87 @@
+import assert from 'node:assert/strict';
+import { test } from 'vitest';
+import { AppError } from '@agent-device/kernel/errors';
+import { createUnsupportedInteractor } from './unsupported-interactor.ts';
+
+// The stub's members are what a composing platform does NOT override, so each platform's own
+// interactor test proves its own list through its composed interactor. This is the factory's
+// behaviour shared by every owner that composes it: one platform-side copy of each case would
+// assert the shared production module twice without adding an owner.
+const REQUIRED_OPERATIONS = [
+  'open',
+  'openDevice',
+  'close',
+  'tap',
+  'longPress',
+  'focus',
+  'type',
+  'fill',
+  'scroll',
+  'screenshot',
+  'snapshot',
+  'back',
+  'setOrientation',
+  'setSetting',
+] as const;
+
+test('the factory covers the whole required interactor surface', () => {
+  const interactor = createUnsupportedInteractor('Vega OS');
+
+  assert.deepEqual(Object.keys(interactor).sort(), [...REQUIRED_OPERATIONS].sort());
+});
+
+test('every required operation rejects as unsupported and names itself and the platform', async () => {
+  const interactor = createUnsupportedInteractor('web');
+
+  for (const operation of REQUIRED_OPERATIONS) {
+    const call = interactor[operation] as () => Promise<unknown>;
+    await expectUnsupported(call, operation, 'web');
+  }
+});
+
+test('the label is per-instance, so two owners refuse with their own wording', async () => {
+  const web = createUnsupportedInteractor('web').setSetting as () => Promise<unknown>;
+  const vega = createUnsupportedInteractor('Vega OS').setSetting as () => Promise<unknown>;
+
+  await expectUnsupported(web, 'setSetting', 'web');
+  await expectUnsupported(vega, 'setSetting', 'Vega OS');
+});
+
+// A fused double-click has no shared-series stand-in, the system buttons ride fact-gated binders,
+// and neither the clipboard nor a TV remote has a shared fallback either: an absent member is the
+// owner's absence, a throw would fake one. The web and Vega fact sets refuse these operations, so
+// their binders must never resolve a member this stub carries.
+test('operations with no shared fallback are left undefined, not denied', () => {
+  const interactor = createUnsupportedInteractor('Vega OS');
+
+  assert.equal(interactor.doubleTap, undefined);
+  assert.equal(interactor.home, undefined);
+  assert.equal(interactor.appSwitcher, undefined);
+  assert.equal(interactor.readClipboard, undefined);
+  assert.equal(interactor.writeClipboard, undefined);
+  assert.equal(interactor.tvRemote, undefined);
+});
+
+test('a refusal carries no partial result the caller could mistake for success', async () => {
+  const interactor = createUnsupportedInteractor('Linux desktop');
+
+  await assert.rejects(
+    async () => await interactor.snapshot(),
+    (error: unknown) =>
+      error instanceof AppError && error.message.endsWith('supported on Linux desktop'),
+  );
+});
+
+async function expectUnsupported(
+  call: () => Promise<unknown>,
+  operation: string,
+  platform: string,
+): Promise<void> {
+  await assert.rejects(
+    call,
+    (error: unknown) =>
+      error instanceof AppError &&
+      error.code === 'UNSUPPORTED_OPERATION' &&
+      error.message === `${operation} is not supported on ${platform}`,
+  );
+}
@@ -1,7 +1,17 @@
 import { AppError } from '@agent-device/kernel/errors';
-import type { Interactor } from '@agent-device/contracts/interactor-types';
+import type { Interactor } from './interactor-types.ts';
 
-// fallow-ignore-next-line code-duplication
+/**
+ * The required `Interactor` surface an owner has not proven, refused one operation at a time.
+ * A platform composes its interactor from this stub and overrides what its backend serves, so
+ * what stays here is what that owner's runtime facts refuse. A refusal names the operation and
+ * the caller's platform label and resolves nothing: a partial result would read as a successful
+ * interaction over an untouched device. Optional members stay absent, never denied — the fused
+ * double-click, the system buttons, the clipboard halves, and the TV remote ride fact-gated
+ * binders, so an absent member is the owner's absence and a denial here would fake a mechanic.
+ * The `Interactor` return type is the pin: a new required member fails to compile until this
+ * stub refuses it too.
+ */
 export function createUnsupportedInteractor(platformLabel: string): Interactor {
   const unsupported = async (operation: string): Promise<never> => {
     throw new AppError(
 
@@ -1,8 +1,8 @@
 import { isDeepLinkTarget } from '@agent-device/contracts/command';
 import type { Interactor, RunnerContext } from '@agent-device/contracts/interactor-types';
+import { createUnsupportedInteractor } from '@agent-device/contracts/unsupported-interactor';
 import type { DeviceInfo } from '@agent-device/kernel/device';
 import { AppError } from '@agent-device/kernel/errors';
-import { createUnsupportedInteractor } from './unsupported-interactor.ts';
 import { closeVegaApp, openVegaApp, openVegaDevice } from './app-lifecycle.ts';
 import { pressVegaTvRemote } from './input-actions.ts';
 
 
@@ -1,10 +1,10 @@
 import type { Interactor } from '@agent-device/contracts/interactor-types';
+import { createUnsupportedInteractor } from '@agent-device/contracts/unsupported-interactor';
 import { AppError } from '@agent-device/kernel/errors';
 import { stripAtPrefix } from '@agent-device/selectors/interaction-positionals';
 import { withDiagnosticTimer } from '@agent-device/host-kit/diagnostics';
 import { resolveWebProviderForHost, type WebProvider } from './index.ts';
 import type { HostEnvironment } from '@agent-device/kernel/source-value';
-import { createUnsupportedInteractor } from './unsupported-interactor.ts';
 
 export async function createWebInteractor(
   host: HostEnvironment,
 
@@ -131,6 +131,7 @@
   "@agent-device/contracts/tv-remote",
   "@agent-device/contracts/tv-remote-runtime",
   "@agent-device/contracts/type-text-runtime",
+  "@agent-device/contracts/unsupported-interactor",
   "@agent-device/contracts/viewport-runtime",
   "@agent-device/contracts/wait",
   "@agent-device/contracts/wait-runtime-plan"