@xopcai/xopc 0.0.414 → 0.0.416

package/dist/src/phone/scrcpy.d.ts

@@ -1,3 +1,4 @@
+import { ScrcpyTextChannel } from './scrcpy-text.js';
 import type { PhoneInteractiveProvider, PhonePointer, PhoneVideoGeometry, PhoneVideoPacket } from './live-provider.js';
 export { readScrcpyServer, scrcpyServerPath, SCRCPY_VERSION, SCRCPY_SHA256 } from './scrcpy-assets.js';
 /** The pinned server sends codec metadata followed by bounded, length-prefixed packets. */
@@ -18,6 +19,7 @@ export declare abstract class ScrcpyProvider implements PhoneInteractiveProvider
     };
     geometry: PhoneVideoGeometry;
     protected closing: boolean;
+    protected textChannel: ScrcpyTextChannel;
     private touch?;
     private listeners;
     private config?;
@@ -29,6 +31,7 @@ export declare abstract class ScrcpyProvider implements PhoneInteractiveProvider
     protected abstract startTransport(): Promise<void>;
     protected abstract write(buffer: Buffer): Promise<void>;
     protected abstract cleanup(): Promise<void>;
+    pasteText(text: string, signal: AbortSignal): Promise<void>;
     start(): Promise<void>;
     protected packet(packet: PhoneVideoPacket): void;
     subscribe(listener: (packet: PhoneVideoPacket) => void): () => void;
@@ -42,6 +45,7 @@ export declare class LocalScrcpyProvider extends ScrcpyProvider {
     private adb;
     private serial;
     private tuning;
+    private textOnly;
     private process?;
     private video?;
     private control?;
@@ -51,7 +55,7 @@ export declare class LocalScrcpyProvider extends ScrcpyProvider {
     constructor(adb: string, serial: string, onFailure: () => void, tuning?: {
         maxSize: number;
         bitRate: number;
-    });
+    }, textOnly?: boolean);
     foreground(signal: AbortSignal): Promise<string>;
     protected startTransport(): Promise<void>;
     protected write(buffer: Buffer): Promise<void>;

package/dist/src/phone/scrcpy.js

@@ -2,6 +2,7 @@ import { PhoneError, init_contracts } from "./contracts.js";
 import { spawnPhoneCommand } from "../process/phone-process.js";
 import { SCRCPY_SHA256, SCRCPY_VERSION } from "../runtime-tools/phone-dependency-catalog.js";
 import { readScrcpyServer, scrcpyServerPath } from "./scrcpy-assets.js";
+import { ScrcpyTextChannel } from "./scrcpy-text.js";
 import { AdbPhoneDriver, runAdb } from "./adb-driver.js";
 import { randomBytes } from "node:crypto";
 import { connect } from "node:net";
@@ -69,6 +70,7 @@ var ScrcpyProvider = class {
 		codec: ""
 	};
 	closing = false;
+	textChannel = new ScrcpyTextChannel((bytes) => this.write(bytes));
 	touch;
 	listeners = /* @__PURE__ */ new Set();
 	config;
@@ -78,6 +80,25 @@ var ScrcpyProvider = class {
 	constructor(onFailure) {
 		this.onFailure = onFailure;
 	}
+	async pasteText(text, signal) {
+		signal.throwIfAborted();
+		const deadline = AbortSignal.any([signal, AbortSignal.timeout(25e3)]);
+		const abort = () => {
+			this.close();
+		};
+		deadline.addEventListener("abort", abort, { once: true });
+		try {
+			try {
+				await this.start();
+				deadline.throwIfAborted();
+			} catch {
+				throw new PhoneError("PHONE_TEXT_INPUT_UNAVAILABLE", "Automatic text input is unavailable. Check Phone settings or take over and type with the phone keyboard.", 409);
+			}
+			await this.textChannel.paste(text, deadline);
+		} finally {
+			deadline.removeEventListener("abort", abort);
+		}
+	}
 	start() {
 		if (this.closing) return Promise.reject(new PhoneError("PHONE_VIDEO_ENDED", "Phone video ended", 409));
 		if (!this.startResult) {
@@ -144,6 +165,7 @@ var ScrcpyProvider = class {
 	}
 	close() {
 		this.closing = true;
+		this.textChannel.close();
 		return this.closeResult ??= (async () => {
 			await this.opening?.catch(() => {});
 			try {
@@ -165,11 +187,12 @@ var LocalScrcpyProvider = class extends ScrcpyProvider {
 	constructor(adb, serial, onFailure, tuning = {
 		maxSize: 960,
 		bitRate: 2e6
-	}) {
+	}, textOnly = false) {
 		super(onFailure);
 		this.adb = adb;
 		this.serial = serial;
 		this.tuning = tuning;
+		this.textOnly = textOnly;
 	}
 	foreground(signal) {
 		return new AdbPhoneDriver(this.adb).foreground(this.serial, signal);
@@ -221,7 +244,8 @@ var LocalScrcpyProvider = class extends ScrcpyProvider {
 				"send_device_meta=false",
 				"send_codec_meta=true",
 				"send_frame_meta=true",
-				"clipboard_autosync=false"
+				"clipboard_autosync=false",
+				...this.textOnly ? ["video=false", "power_on=false"] : []
 			]);
 			this.process.once("error", () => this.fail());
 			this.process.once("exit", () => this.fail());
@@ -259,6 +283,21 @@ var LocalScrcpyProvider = class extends ScrcpyProvider {
 				await setTimeout$1(50);
 			}
 			if (!this.video) throw new Error("Scrcpy connection timed out");
+			if (this.textOnly) {
+				this.control = this.video;
+				this.video = void 0;
+				this.control.setNoDelay(true);
+				this.control.on("error", () => this.fail());
+				this.control.on("end", () => this.fail());
+				this.control.on("data", (data) => {
+					try {
+						this.textChannel.receive(Buffer.from(data));
+					} catch {
+						this.fail();
+					}
+				});
+				return;
+			}
 			const parser = new ScrcpyVideoParser();
 			this.video.on("data", (data) => {
 				try {
@@ -276,7 +315,13 @@ var LocalScrcpyProvider = class extends ScrcpyProvider {
 			this.control.setNoDelay(true);
 			this.control.on("error", () => this.fail());
 			this.control.on("end", () => this.fail());
-			this.control.on("data", () => {});
+			this.control.on("data", (data) => {
+				try {
+					this.textChannel.receive(Buffer.from(data));
+				} catch {
+					this.fail();
+				}
+			});
 			await new Promise((resolve, reject) => {
 				this.control.once("connect", resolve);
 				this.control.once("error", reject);

package/dist/src/phone/semantic-controls.d.ts

@@ -0,0 +1,13 @@
+import { type PhoneAction, type PhoneElementSelector, type PhoneObservation } from './contracts.js';
+export type PhonePrimitiveAction = Exclude<PhoneAction, {
+    type: 'tapElement';
+}>;
+/** Offer exact identities only when one fully visible native node matches. */
+export declare function phoneSemanticControls(screen: PhoneObservation): Array<{
+    frameId: string;
+    selector: PhoneElementSelector;
+}>;
+/** Ground ordinary model taps only when native hit-testing identifies one bounded control. */
+export declare function groundPhoneCoordinateAction(action: PhoneAction, screen: PhoneObservation): PhoneAction;
+/** Resolve against the prediction snapshot and a fresh snapshot before any dispatch. */
+export declare function resolvePhoneSemanticAction(action: PhoneAction, predicted: PhoneObservation, fresh?: PhoneObservation): PhonePrimitiveAction;

package/dist/src/phone/semantic-controls.js

@@ -0,0 +1,76 @@
+import { PhoneActionSchema, PhoneError, init_contracts } from "./contracts.js";
+import { canDispatchPhoneAction } from "./reliability.js";
+//#region src/phone/semantic-controls.ts
+init_contracts();
+function visible(node, screen) {
+	const [left, top, right, bottom] = node.bounds;
+	return !node.password && node.bounds.every(Number.isFinite) && left >= 0 && top >= 0 && right <= screen.width && bottom <= screen.height && right > left && bottom > top;
+}
+function matches(node, selector) {
+	return (selector.resourceId === void 0 || node.resourceId === selector.resourceId) && (selector.text === void 0 || node.text === selector.text) && (selector.description === void 0 || node.description === selector.description);
+}
+function candidates(screen, selector) {
+	return screen.elements.filter((node) => visible(node, screen) && matches(node, selector));
+}
+function exactSelector(node) {
+	const selector = {};
+	if (node.resourceId && node.resourceId.length <= 300) selector.resourceId = node.resourceId;
+	if (node.text && node.text.length <= 4e3) selector.text = node.text;
+	if (node.description && node.description.length <= 1e3) selector.description = node.description;
+	return selector;
+}
+/** Offer exact identities only when one fully visible native node matches. */
+function phoneSemanticControls(screen) {
+	return screen.elements.filter((node) => visible(node, screen)).flatMap((node) => {
+		const selector = exactSelector(node);
+		return Object.keys(selector).length && candidates(screen, selector).length === 1 ? [{
+			frameId: screen.frameId,
+			selector
+		}] : [];
+	}).slice(0, 40);
+}
+function containsPoint(node, x, y) {
+	return x >= node.bounds[0] && y >= node.bounds[1] && x < node.bounds[2] && y < node.bounds[3];
+}
+function containsNode(outer, inner) {
+	return outer.bounds[0] <= inner.bounds[0] && outer.bounds[1] <= inner.bounds[1] && outer.bounds[2] >= inner.bounds[2] && outer.bounds[3] >= inner.bounds[3];
+}
+/** Ground ordinary model taps only when native hit-testing identifies one bounded control. */
+function groundPhoneCoordinateAction(action, screen) {
+	if (action.type !== "tap") return action;
+	const [x, y] = [action.point[0] * screen.width / 1e3, action.point[1] * screen.height / 1e3];
+	if (screen.elements.some((node) => node.password && containsPoint(node, x, y))) return action;
+	const actionable = screen.elements.filter((node) => visible(node, screen) && (node.clickable || node.editable));
+	const hits = actionable.filter((node) => containsPoint(node, x, y));
+	const smallest = hits.filter((node) => hits.every((other) => other === node || containsNode(other, node)));
+	if (smallest.length !== 1) return action;
+	const target = smallest[0];
+	if ((target.bounds[2] - target.bounds[0]) * (target.bounds[3] - target.bounds[1]) > screen.width * screen.height / 4) return action;
+	const selector = exactSelector(target);
+	if (!Object.keys(selector).length || candidates(screen, selector).length !== 1) return action;
+	const [centerX, centerY] = [(target.bounds[0] + target.bounds[2]) / 2, (target.bounds[1] + target.bounds[3]) / 2];
+	if (screen.elements.some((node) => node.password && containsPoint(node, centerX, centerY)) || actionable.some((node) => node !== target && containsPoint(node, centerX, centerY) && !containsNode(node, target))) return action;
+	return {
+		type: "tapElement",
+		frameId: screen.frameId,
+		selector
+	};
+}
+/** Resolve against the prediction snapshot and a fresh snapshot before any dispatch. */
+function resolvePhoneSemanticAction(action, predicted, fresh = predicted) {
+	if (action.type !== "tapElement") return action;
+	if (!PhoneActionSchema.safeParse(action).success) throw new PhoneError("PHONE_SEMANTIC_INVALID", "Invalid exact native element selector", 409);
+	if (action.frameId !== predicted.frameId) throw new PhoneError("PHONE_SEMANTIC_STALE", "Native element belongs to a different observation", 409);
+	const before = candidates(predicted, action.selector);
+	const after = candidates(fresh, action.selector);
+	if (before.length !== 1 || after.length !== 1) throw new PhoneError("PHONE_SEMANTIC_TARGET", "Native element selector must match exactly one fully visible non-password node", 409);
+	const target = after[0];
+	const resolved = {
+		type: "tap",
+		point: [500 * (target.bounds[0] + target.bounds[2]) / fresh.width, 500 * (target.bounds[1] + target.bounds[3]) / fresh.height]
+	};
+	if (JSON.stringify(before[0]) !== JSON.stringify(target) || !canDispatchPhoneAction(resolved, predicted, fresh)) throw new PhoneError("PHONE_SEMANTIC_STALE", "Native element or page changed before dispatch", 409);
+	return resolved;
+}
+//#endregion
+export { groundPhoneCoordinateAction, phoneSemanticControls, resolvePhoneSemanticAction };

package/dist/src/phone/setup/service.d.ts

@@ -0,0 +1,148 @@
+import type { PhoneSetupView } from '@xopcai/gateway-contract';
+import type { PhoneInput } from '../contracts.js';
+import type { PhoneRuntime } from '../runtime.js';
+type Context = {
+    conversationId: string;
+    agentId: string;
+};
+type Setup = Omit<PhoneSetupView, 'readiness' | 'stale' | 'settingsPath' | 'guidanceRefs'> & {
+    environmentRevision?: string;
+    calls: number;
+    owner?: string;
+};
+export interface PhoneSetupDeps {
+    runtime: PhoneRuntime;
+    inspect(context: Context, source?: 'local' | 'aliyun'): Promise<PhoneSetupView['readiness']>;
+    revision(context: Context, deviceId: string): string;
+    connected(deviceId: string, signal?: AbortSignal): Promise<boolean>;
+    leaseActive(deviceId: string): boolean;
+}
+/** Setup only orchestrates existing settings; secrets and configuration writes stay in product forms. */
+export declare class PhoneSetupService {
+    private readonly deps;
+    constructor(deps: PhoneSetupDeps);
+    private store;
+    current(context: Context): Setup;
+    private save;
+    private owned;
+    view(context: Context, setup: Setup): Promise<PhoneSetupView>;
+    command(command: string, args: Record<string, unknown>, context: Context, dryRun?: boolean): Promise<PhoneSetupView | {
+        dryRun?: boolean;
+        sceneId: string;
+        skillName: string;
+        readiness: {
+            enabled: boolean;
+            toolAllowed: boolean;
+            model: {
+                ref?: string;
+                chatRef?: string;
+                source?: "system" | "global" | "agent";
+                supported: boolean;
+                configured: boolean;
+            };
+            dependencies: Array<{
+                kind: "adb" | "scrcpy";
+                state: string;
+                version?: string;
+                canInstall: boolean;
+            }>;
+            devices: Array<{
+                id: string;
+                name: string;
+                source: "local" | "aliyun";
+                enabled: boolean;
+                settingsAllowed: boolean;
+            }>;
+            localDiscovery: Array<{
+                name: string;
+                state: string;
+                emulator: boolean;
+            }>;
+            diagnostic?: string;
+        };
+        setup: PhoneSetupView;
+        settingsPath: string;
+        guidanceRefs: {
+            sceneId: string;
+            path: string;
+            resourceVersion: string;
+        }[];
+    } | {
+        message: string;
+        id: string;
+        conversationId: string;
+        agentId: string;
+        revision: number;
+        state: "configuring" | "verifying" | "completed" | "needs_attention" | "cancelled";
+        source?: "local" | "aliyun";
+        error?: string;
+        stale: boolean;
+        settingsPath: string;
+        readiness: {
+            enabled: boolean;
+            toolAllowed: boolean;
+            model: {
+                ref?: string;
+                chatRef?: string;
+                source?: "system" | "global" | "agent";
+                supported: boolean;
+                configured: boolean;
+            };
+            dependencies: Array<{
+                kind: "adb" | "scrcpy";
+                state: string;
+                version?: string;
+                canInstall: boolean;
+            }>;
+            devices: Array<{
+                id: string;
+                name: string;
+                source: "local" | "aliyun";
+                enabled: boolean;
+                settingsAllowed: boolean;
+            }>;
+            localDiscovery: Array<{
+                name: string;
+                state: string;
+                emulator: boolean;
+            }>;
+            diagnostic?: string;
+        };
+        checks: {
+            configured: boolean;
+            read: boolean;
+            operated: boolean;
+            verified: boolean;
+            released: boolean;
+        };
+        attempt?: {
+            id: string;
+            deviceId: string;
+            modelRef: string;
+            sessionId?: string;
+            goal: string;
+            completion: {
+                appPackage: string;
+                textAny: string[];
+                requireChange: boolean;
+            };
+            maxActions: number;
+            expiresAt: number;
+            released: boolean;
+        };
+        guidanceRefs: Array<{
+            sceneId: "phone";
+            path: string;
+            resourceVersion: string;
+        }>;
+    }>;
+    source(context: Context, id: string, source: 'local' | 'aliyun', revision: number): Promise<PhoneSetupView>;
+    begin(context: Context, id: string, deviceId: string, revision: number, signal?: AbortSignal): Promise<PhoneSetupView>;
+    beforeInput(context: Context, input: PhoneInput): {
+        owner: string;
+        input: PhoneInput;
+    } | undefined;
+    afterInput(context: Context, owner: string, op: PhoneInput['op']): void;
+    release(context: Context, id: string): Promise<PhoneSetupView>;
+}
+export {};

package/dist/src/phone/setup/service.js

@@ -0,0 +1,251 @@
+import { DurableState } from "../../storage/sqlite/durable-state.js";
+import { randomUUID } from "node:crypto";
+//#region src/phone/setup/service.ts
+/** Setup only orchestrates existing settings; secrets and configuration writes stay in product forms. */
+var PhoneSetupService = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	store(context) {
+		return new DurableState("phone.setup", context.conversationId);
+	}
+	current(context) {
+		return this.store(context).get(context.agentId);
+	}
+	save(context, next, expected = next.revision) {
+		return this.store(context).update(context.agentId, (previous) => {
+			if (previous && previous.revision !== expected) throw new Error("PHONE_SETUP_CONFLICT: Refresh the saved progress.");
+			const value = {
+				...next,
+				revision: expected + 1
+			};
+			return {
+				value,
+				result: value
+			};
+		});
+	}
+	owned(context, id) {
+		const setup = this.current(context);
+		if (!setup || setup.id !== id) throw new Error("PHONE_SETUP_NOT_FOUND");
+		return setup;
+	}
+	async view(context, setup) {
+		const { owner: _owner, calls: _calls, environmentRevision: _revision, ...summary } = setup;
+		const stale = Boolean(setup.attempt && setup.environmentRevision !== this.deps.revision(context, setup.attempt.deviceId));
+		const interrupted = setup.state === "verifying" && (Date.now() > setup.attempt.expiresAt || Boolean(setup.attempt?.sessionId && !this.deps.runtime.status(setup.owner)));
+		return {
+			...summary,
+			stale,
+			state: interrupted ? "needs_attention" : setup.state,
+			error: interrupted ? "PHONE_SETUP_INTERRUPTED: Release or confirm lease expiry before starting a fresh test." : setup.error,
+			readiness: await this.deps.inspect(context, setup.source),
+			settingsPath: `/settings/phone-use?phoneSetup=${setup.id}&conversationId=${context.conversationId}`,
+			guidanceRefs: [{
+				sceneId: "phone",
+				path: `references/phone/${setup.state === "verifying" ? "acceptance" : setup.error || interrupted || stale ? "troubleshooting" : setup.source === "aliyun" ? "aliyun" : setup.source === "local" ? "local" : "overview"}.md`,
+				resourceVersion: "1"
+			}]
+		};
+	}
+	async command(command, args, context, dryRun = false) {
+		let setup = this.current(context);
+		if (command === "inspect" || command === "preview" || dryRun) return {
+			sceneId: "phone",
+			skillName: "configure-xopc",
+			readiness: await this.deps.inspect(context, setup?.source),
+			setup: setup ? await this.view(context, setup) : null,
+			settingsPath: `/settings/phone-use?conversationId=${context.conversationId}`,
+			guidanceRefs: [{
+				sceneId: "phone",
+				path: "references/phone/overview.md",
+				resourceVersion: "1"
+			}],
+			...dryRun ? { dryRun: true } : {}
+		};
+		if (command === "start") {
+			if (!setup || ["completed", "cancelled"].includes(setup.state) && (!setup.attempt || setup.attempt.released)) setup = this.save(context, {
+				id: randomUUID(),
+				...context,
+				state: "configuring",
+				revision: setup?.revision ?? 0,
+				calls: 0,
+				checks: {
+					configured: false,
+					read: false,
+					operated: false,
+					verified: false,
+					released: false
+				}
+			});
+			return this.view(context, setup);
+		}
+		if (typeof args.setupId !== "string") throw new Error("setupId is required");
+		setup = this.owned(context, args.setupId);
+		if ([
+			"get",
+			"recheck",
+			"verification_report"
+		].includes(command)) return this.view(context, setup);
+		if (command === "begin_verification") return {
+			...await this.view(context, setup),
+			message: "Choose the phone and approve the Settings-only test in the original conversation panel."
+		};
+		if (command === "cancel") {
+			setup = this.save(context, {
+				...setup,
+				state: "cancelled"
+			});
+			return this.release(context, setup.id);
+		}
+		throw new Error("Unsupported phone_setup command");
+	}
+	async source(context, id, source, revision) {
+		const setup = this.owned(context, id);
+		if (setup.revision !== revision || setup.attempt && !setup.attempt.released) throw new Error("PHONE_SETUP_CONFLICT: Release the active test before changing connection.");
+		if (setup.state === "cancelled" || setup.state === "completed") throw new Error("PHONE_SETUP_CLOSED: Start a new setup before changing connection.");
+		return this.view(context, this.save(context, {
+			...setup,
+			source
+		}));
+	}
+	async begin(context, id, deviceId, revision, signal) {
+		let setup = this.owned(context, id);
+		if (setup.revision !== revision || setup.state === "cancelled" || setup.attempt && !setup.attempt.released) throw new Error("PHONE_SETUP_CONFLICT: Refresh progress and release the old test.");
+		const environmentRevision = this.deps.revision(context, deviceId);
+		const readiness = await this.deps.inspect(context, setup.source);
+		const device = readiness.devices.find((device) => device.id === deviceId);
+		if (!readiness.enabled || !readiness.toolAllowed) throw new Error("PHONE_SETUP_PERMISSION_REQUIRED: Enable Phone Use and allow this Agent in product settings.");
+		if (!readiness.model.ref || !readiness.model.supported || !readiness.model.configured) throw new Error("PHONE_SETUP_MODEL_REQUIRED: Save a configured real Phone Use model.");
+		if (!device?.enabled || !device.settingsAllowed) throw new Error("PHONE_SETUP_DEVICE_REQUIRED: Choose an enabled phone allowing Settings.");
+		if (setup.source && setup.source !== device.source) throw new Error("PHONE_SETUP_SOURCE_MISMATCH");
+		if (device.source === "local" && !readiness.dependencies.some((item) => item.kind === "adb" && item.state === "ready")) throw new Error("PHONE_SETUP_ADB_REQUIRED");
+		if (!await this.deps.connected(deviceId, signal)) throw new Error("PHONE_SETUP_DEVICE_OFFLINE: Authorize USB debugging or check cloud connection.");
+		const latest = this.owned(context, id);
+		if (latest.revision !== revision || environmentRevision !== this.deps.revision(context, deviceId)) throw new Error("PHONE_SETUP_CONFLICT");
+		const attempt = {
+			id: randomUUID(),
+			deviceId,
+			modelRef: readiness.model.ref,
+			goal: "From the Android Settings About phone page, open Android version details and read the version. Do not change any setting.",
+			completion: {
+				appPackage: "com.android.settings",
+				textAny: [
+					"Android version",
+					"Android 版本",
+					"Android版本"
+				],
+				requireChange: true
+			},
+			maxActions: 6,
+			expiresAt: Date.now() + 3e5,
+			released: false
+		};
+		setup = this.save(context, {
+			...latest,
+			state: "verifying",
+			source: device.source,
+			error: void 0,
+			attempt,
+			owner: `phone-setup:${latest.id}:${attempt.id}`,
+			environmentRevision,
+			calls: 0,
+			checks: {
+				configured: true,
+				read: false,
+				operated: false,
+				verified: false,
+				released: false
+			}
+		});
+		return this.view(context, setup);
+	}
+	beforeInput(context, input) {
+		const setup = this.current(context);
+		if (!setup?.attempt || setup.attempt.released || input.op === "discover") return void 0;
+		const cleanup = input.op === "close" || input.op === "cancel";
+		if (!cleanup && (setup.state !== "verifying" || Date.now() > setup.attempt.expiresAt || setup.calls >= 12 || setup.environmentRevision !== this.deps.revision(context, setup.attempt.deviceId))) throw new Error("PHONE_SETUP_STOPPED: Release the setup test and review the current state.");
+		if (!(cleanup || input.op === "status" || input.op === "observe" || input.op === "pause" || input.op === "open" && input.deviceId === setup.attempt.deviceId && input.mode === "control" && input.appPackage === "com.android.settings" || (input.op === "run" || input.op === "step") && input.goal === setup.attempt.goal && !input.scenario && input.completion?.appPackage === setup.attempt.completion.appPackage && input.completion.requireChange === true && JSON.stringify(input.completion.textAny) === JSON.stringify(setup.attempt.completion.textAny) && !input.completion.textAll && !input.completion.field && (input.maxActions ?? 6) <= 6)) throw new Error("PHONE_SETUP_ACTION_DENIED: Use only the approved Settings test.");
+		this.save(context, {
+			...setup,
+			calls: setup.calls + 1
+		});
+		if (input.op === "run" || input.op === "step") {
+			const report = this.deps.runtime.status(setup.owner);
+			const openingActions = report?.steps[0]?.action === "launch" ? 1 : 0;
+			const remaining = 6 - Math.max(0, (report?.actions ?? 0) - openingActions);
+			if (remaining <= 0) throw new Error("PHONE_SETUP_BUDGET_EXHAUSTED: Close the test and review its evidence.");
+			return {
+				owner: setup.owner,
+				input: {
+					...input,
+					maxActions: Math.min(input.maxActions ?? 6, remaining)
+				}
+			};
+		}
+		return {
+			owner: setup.owner,
+			input: input.op === "open" ? {
+				...input,
+				settingsPage: "about-phone"
+			} : input
+		};
+	}
+	afterInput(context, owner, op) {
+		const setup = this.current(context);
+		if (!setup?.attempt || setup.owner !== owner) return;
+		const report = this.deps.runtime.status(owner);
+		if (!report || report.deviceId !== setup.attempt.deviceId || report.modelRef !== setup.attempt.modelRef || setup.attempt.sessionId && report.sessionId !== setup.attempt.sessionId) return;
+		const released = op === "close" && report.status === "closed" && report.controlOwner === "none";
+		const valid = setup.state === "verifying" && setup.environmentRevision === this.deps.revision(context, report.deviceId) && Date.now() <= setup.attempt.expiresAt;
+		const modelActions = Math.max(0, report.actions - (report.steps[0]?.action === "launch" ? 1 : 0));
+		const verified = valid && !report.mock && report.mode === "control" && report.verified && report.verificationLevel === "ui" && report.modelRequests > 0 && modelActions > 0;
+		const checks = {
+			...setup.checks,
+			...valid ? {
+				read: setup.checks.read || Boolean(report.facts?.length),
+				operated: setup.checks.operated || modelActions > 0,
+				verified: setup.checks.verified || verified
+			} : {},
+			released: setup.checks.released || released
+		};
+		this.save(context, {
+			...setup,
+			checks,
+			attempt: {
+				...setup.attempt,
+				sessionId: report.sessionId,
+				released: checks.released
+			},
+			state: setup.state === "cancelled" ? "cancelled" : released ? valid && checks.verified && checks.read ? "completed" : "needs_attention" : setup.state,
+			error: released && !(valid && checks.verified && checks.read) ? report.errorCode === "PHONE_MODEL_QUOTA_EXHAUSTED" ? "PHONE_MODEL_QUOTA_EXHAUSTED: Wait for the Phone model quota to reset or select a configured compatible model; device control was released." : "PHONE_SETUP_INCOMPLETE: Review progress and start a fresh test." : setup.error
+		});
+	}
+	async release(context, id) {
+		let setup = this.owned(context, id);
+		if (!setup.attempt || setup.attempt.released) return this.view(context, setup);
+		if (!this.deps.runtime.status(setup.owner)) {
+			if (this.deps.leaseActive(setup.attempt.deviceId)) throw new Error("PHONE_SETUP_LEASE_PENDING: Control expiry is not confirmed yet. Wait and recheck.");
+			setup = this.save(context, {
+				...setup,
+				state: setup.state === "cancelled" ? "cancelled" : "needs_attention",
+				attempt: {
+					...setup.attempt,
+					released: true
+				},
+				checks: {
+					...setup.checks,
+					released: true
+				},
+				error: "PHONE_SETUP_RESTARTED: Lease expiry confirmed; start a fresh test."
+			});
+		} else {
+			await this.deps.runtime.stop(setup.owner, "close");
+			this.afterInput(context, setup.owner, "close");
+			setup = this.owned(context, id);
+		}
+		return this.view(context, setup);
+	}
+};
+//#endregion
+export { PhoneSetupService };

package/dist/src/providers/presentation.js

@@ -239,7 +239,7 @@ function modelToCatalogView(model) {
 		...model.contextWindow ? { contextWindow: model.contextWindow } : {},
 		...model.maxTokens ? { maxTokens: model.maxTokens } : {},
 		vision: input.includes("image"),
-		recommended: !isDedicatedComputerModel(model) && isRecommendedModel(model.provider, model.id)
+		recommended: !("phoneUse" in model && model.phoneUse) && !isDedicatedComputerModel(model) && isRecommendedModel(model.provider, model.id)
 	};
 }
 function presetModelToCatalogView(provider, model) {
@@ -267,7 +267,7 @@ function sortModelsForPicker(models) {
 	});
 }
 function getRecommendedModelsForProvider(provider, limit = 4) {
-	const fromRegistry = sortModelsForPicker(getModelsByProvider(provider)).filter((model) => !isDedicatedComputerModel(model) && isRecommendedModel(provider, model.id)).slice(0, limit).map(modelToCatalogView);
+	const fromRegistry = sortModelsForPicker(getModelsByProvider(provider)).filter((model) => !("phoneUse" in model && model.phoneUse) && !isDedicatedComputerModel(model) && isRecommendedModel(provider, model.id)).slice(0, limit).map(modelToCatalogView);
 	if (fromRegistry.length > 0) return fromRegistry;
 	const preset = getDomesticProviderPreset(provider);
 	if (!preset) return [];