@p4code/cli 0.5.5 → 0.5.6

package/dist/bin.mjs

@@ -19,8 +19,11 @@ import "effect/LogLevel";
 import * as Path$1 from "effect/Path";
 import * as Schema$1 from "effect/Schema";
 import * as NodePath from "node:path";
+import { isAbsolute } from "node:path";
 import * as NodeChildProcess from "node:child_process";
+import { spawn } from "node:child_process";
 import * as NodeFS from "node:fs";
+import { constants } from "node:fs";
 import * as DateTime from "effect/DateTime";
 import * as Duration from "effect/Duration";
 import * as Option from "effect/Option";
@@ -42,6 +45,7 @@ import * as Config from "effect/Config";
 import * as References from "effect/References";
 import * as HttpServerRequest$1 from "effect/unstable/http/HttpServerRequest";
 import * as NodeCrypto from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import * as Encoding from "effect/Encoding";
 import * as Result$1 from "effect/Result";
 import * as Crypto from "effect/Crypto";
@@ -57,6 +61,7 @@ import * as Cause from "effect/Cause";
 import * as Exit from "effect/Exit";
 import * as NodeReadline from "node:readline";
 import * as NodeFSP from "node:fs/promises";
+import { access } from "node:fs/promises";
 import * as Clock from "effect/Clock";
 import * as NodeStream from "@effect/platform-node/NodeStream";
 import * as NodeHttp from "node:http";
@@ -260,7 +265,7 @@ const make$116 = () => {
 const layer$119 = Layer.sync(NetService, make$116);
 //#endregion
 //#region package.json
-var version$1 = "0.5.5";
+var version$1 = "0.5.6";
 //#endregion
 //#region src/config.ts
 /**
@@ -7823,6 +7828,7 @@ const TaskProgressPayload = Schema$1.Struct({
 	usage: Schema$1.optional(Schema$1.Unknown),
 	lastToolName: Schema$1.optional(TrimmedNonEmptyStringSchema$1),
 	toolUseId: Schema$1.optional(TrimmedNonEmptyStringSchema$1),
+	model: Schema$1.optional(TrimmedNonEmptyStringSchema$1),
 	subagentType: Schema$1.optional(TrimmedNonEmptyStringSchema$1)
 });
 const TaskCompletedPayload = Schema$1.Struct({
@@ -8838,7 +8844,11 @@ const DeviceHostSummary = Schema$1.Struct({
 	label: TrimmedNonEmptyString.check(Schema$1.isMaxLength(MAX_HOST_LABEL_LENGTH)),
 	platforms: Schema$1.Array(DevicePlatformAvailability),
 	hubInstalled: Schema$1.Boolean,
-	agentDeviceInstalled: Schema$1.Boolean
+	agentDeviceInstalled: Schema$1.Boolean,
+	automation: Schema$1.optional(Schema$1.Struct({
+		provider: Schema$1.Literals(["apple-xcode", "xcodebuildmcp"]),
+		detail: Schema$1.String
+	}))
 });
 /**
 * Lifecycle of the helper processes on a host. Tools are installed on first
@@ -13591,6 +13601,45 @@ const ComputerUseDeviceTarget = {
 	deviceId: DeviceId,
 	leaseId: DeviceId
 };
+const DeviceElementRef = TrimmedNonEmptyString.check(Schema$1.isMaxLength(128));
+const DeviceGesture = {
+	direction: Schema$1.Literals([
+		"up",
+		"down",
+		"left",
+		"right"
+	]),
+	distance: Schema$1.optional(Schema$1.Number.check(Schema$1.isGreaterThan(0), Schema$1.isLessThanOrEqualTo(1)))
+};
+const ComputerUseDeviceAction = Schema$1.Union([
+	Schema$1.Struct({
+		action: Schema$1.Literal("tap"),
+		elementRef: DeviceElementRef
+	}),
+	Schema$1.Struct({
+		action: Schema$1.Literal("type_text"),
+		elementRef: DeviceElementRef,
+		text: Schema$1.String.check(Schema$1.isMinLength(1), Schema$1.isMaxLength(16e3)),
+		replaceExisting: Schema$1.optional(Schema$1.Boolean)
+	}),
+	Schema$1.Struct({
+		action: Schema$1.Literal("swipe"),
+		withinElementRef: DeviceElementRef,
+		...DeviceGesture
+	}),
+	Schema$1.Struct({
+		action: Schema$1.Literal("drag"),
+		elementRef: DeviceElementRef,
+		...DeviceGesture
+	}),
+	Schema$1.Struct({
+		action: Schema$1.Literal("batch"),
+		steps: Schema$1.Array(Schema$1.Struct({
+			action: Schema$1.Literal("tap"),
+			elementRef: DeviceElementRef
+		})).check(Schema$1.isMinLength(1), Schema$1.isMaxLength(100))
+	})
+]);
 const ComputerUseDeviceOperation = Schema$1.Union([
 	Schema$1.Struct({ method: Schema$1.Literal("list") }),
 	Schema$1.Struct({
@@ -13605,7 +13654,18 @@ const ComputerUseDeviceOperation = Schema$1.Union([
 			"screenshot",
 			"close"
 		]),
-		...ComputerUseDeviceTarget
+		...ComputerUseDeviceTarget,
+		sinceScreenHash: Schema$1.optional(TrimmedNonEmptyString)
+	}),
+	Schema$1.Struct({
+		method: Schema$1.Literal("semantic"),
+		...ComputerUseDeviceTarget,
+		action: ComputerUseDeviceAction
+	}),
+	Schema$1.Struct({
+		method: Schema$1.Literal("recording"),
+		...ComputerUseDeviceTarget,
+		action: Schema$1.Literals(["start", "stop"])
 	}),
 	Schema$1.Struct({
 		method: Schema$1.Literal("command"),
@@ -13717,6 +13777,7 @@ const WS_METHODS = {
 	serverGetProcessDiagnostics: "server.getProcessDiagnostics",
 	serverGetProcessResourceHistory: "server.getProcessResourceHistory",
 	serverSignalProcess: "server.signalProcess",
+	threadHandoff: "thread.handoff",
 	btwAsk: "btw.ask",
 	btwCancel: "btw.cancel",
 	pullRequestsList: "pullRequests.list",
@@ -14360,6 +14421,14 @@ const WsServerGetProviderUsageRpc = Rpc.make(WS_METHODS.serverGetProviderUsage,
 	success: Schema$1.Struct({ report: Schema$1.String }),
 	error: Schema$1.Union([TextGenerationError, EnvironmentAuthorizationError])
 });
+const WsThreadHandoffRpc = Rpc.make(WS_METHODS.threadHandoff, {
+	payload: Schema$1.Struct({ threadId: ThreadId }),
+	success: Schema$1.Struct({
+		projectId: ProjectId,
+		text: Schema$1.String
+	}),
+	error: Schema$1.Union([TextGenerationError, EnvironmentAuthorizationError])
+});
 const WsBtwAskRpc = Rpc.make(WS_METHODS.btwAsk, {
 	payload: BtwAskInput,
 	success: BtwAskResult,
@@ -14820,7 +14889,7 @@ const WsSubscribeAuthAccessRpc = Rpc.make(WS_METHODS.subscribeAuthAccess, {
 	error: Schema$1.Union([AuthAccessStreamError, EnvironmentAuthorizationError]),
 	stream: true
 });
-const WsRpcGroup = RpcGroup.make(WsDeviceGetStateRpc, WsDeviceListRpc, WsDeviceConfigureRpc, WsDeviceOpenRpc, WsDeviceCloseRpc, WsDeviceDetailRpc, WsDeviceActionRpc, WsSubscribeDevicesRpc, WsServerProbeRpc, WsServerGetConfigRpc, WsServerRefreshProvidersRpc, WsServerProviderAuthStartRpc, WsServerProviderAuthCompleteRpc, WsServerProviderAuthCancelRpc, WsServerProviderAuthLogoutRpc, WsServerProviderAuthSubscribeRpc, WsServerProviderInstallStartRpc, WsServerProviderInstallCancelRpc, WsServerProviderInstallRemoveRpc, WsServerProviderInstallSubscribeRpc, WsServerUpdateProviderRpc, WsServerUpdateServerRpc, WsServerUpsertKeybindingRpc, WsServerRemoveKeybindingRpc, WsServerGetSettingsRpc, WsServerUpdateSettingsRpc, WsServerDiscoverSourceControlRpc, WsServerGetProviderUsageRpc, WsServerGetHostResourcesRpc, WsServerGetResourceTelemetryRpc, WsServerGetResourceTelemetryHistoryRpc, WsServerRetryResourceTelemetryRpc, WsSubscribeResourceTelemetryRpc, WsBtwAskRpc, WsBtwCancelRpc, WsServerGetUsageSummaryRpc, WsServerGetTraceDiagnosticsRpc, WsServerGetProcessDiagnosticsRpc, WsServerGetProcessResourceHistoryRpc, WsServerSignalProcessRpc, WsPullRequestsListRpc, WsPullRequestsListStatsRpc, WsPullRequestsDetailRpc, WsPullRequestsStackRpc, WsPullRequestsActivityRpc, WsPullRequestsDiffFileContentsRpc, WsPullRequestsRunActionRpc, WsPullRequestsUpdateRpc, WsPullRequestsCommentRpc, WsPullRequestsUpdateCommentRpc, WsPullRequestsSubmitReviewRpc, WsPullRequestsReplyToThreadRpc, WsPullRequestsSetThreadResolutionRpc, WsPullRequestsSetReactionRpc, WsPullRequestsInvalidateRpc, WsPullRequestsReviewerCandidatesRpc, WsPullRequestsRequestReviewersRpc, WsSourceControlLookupRepositoryRpc, WsSourceControlCloneRepositoryRpc, WsSourceControlPublishRepositoryRpc, WsProjectsListEntriesRpc, WsProjectsReadFileRpc, WsProjectsSearchContentsRpc, WsProjectsSearchEntriesRpc, WsProjectsWriteFileRpc, WsShellOpenInEditorRpc, WsFilesystemBrowseRpc, WsAssetsCreateUrlRpc, WsSubscribeVcsStatusRpc, WsVcsPullRpc, WsVcsRefreshStatusRpc, WsGitRunStackedActionRpc, WsGitResolvePullRequestRpc, WsGitPreparePullRequestThreadRpc, WsVcsListRefsRpc, WsVcsCreateWorktreeRpc, WsVcsRemoveWorktreeRpc, WsVcsCreateRefRpc, WsVcsSwitchRefRpc, WsVcsInitRpc, WsReviewGetDiffPreviewRpc, WsTerminalOpenRpc, WsTerminalAttachRpc, WsTerminalWriteRpc, WsTerminalResizeRpc, WsTerminalClearRpc, WsTerminalRestartRpc, WsTerminalCloseRpc, WsSubscribeTerminalEventsRpc, WsSubscribeTerminalMetadataRpc, WsPreviewOpenRpc, WsPreviewNavigateRpc, WsPreviewResizeRpc, WsPreviewRefreshRpc, WsPreviewCloseRpc, WsPreviewListRpc, WsPreviewReportStatusRpc, WsComputerUseConnectRpc, WsComputerUseListRpc, WsComputerUseControlsRpc, WsComputerUseControlRpc, WsComputerUsePreviewRpc, WsComputerUseRespondRpc, WsPreviewAutomationConnectRpc, WsPreviewAutomationRespondRpc, WsPreviewAutomationFocusHostRpc, WsSubscribePreviewEventsRpc, WsSubscribeDiscoveredLocalServersRpc, WsSubscribeServerConfigRpc, WsSubscribeServerLifecycleRpc, WsSubscribeAuthAccessRpc, WsTasksListRpc, WsTasksGetRpc, WsTasksCreateRpc, WsTasksUpdateRpc, WsTasksDeleteRpc, WsTasksStartThreadRpc, WsFeedListRpc, WsFeedRefreshRpc, WsFeedSourcesListRpc, WsFeedSourcesUpsertRpc, WsFeedSourcesDeleteRpc, WsFeedMarkReadRpc, WsFeedCleanupRpc, WsSubscribeTasksRpc, WsHubGetSyncStatusRpc, WsHubConnectRpc, WsHubDisconnectRpc, WsHubSetSyncModeRpc, WsHubSetShareModeRpc, WsHubMintTokenRpc, WsSkillsSyncRpc, WsSkillsPublishRpc, WsSkillsPublishAllRpc, WsSkillsUnpublishRpc, WsAssetsReadRpc, WsAssetsSaveRpc, WsAssetsDeleteRpc, WsAssetsCreateLocalRpc, WsAssetsRemoveLocalRpc, WsSkillRegistrySearchRpc, WsSkillRegistryFetchRpc, WsMcpListRpc, WsMcpSaveRpc, WsMcpRemoveRpc, WsMcpSetSecretRpc, WsMcpOAuthBeginRpc, WsMcpOAuthDisconnectRpc, WsTrackerStatusRpc, WsTrackerSetApiKeyRpc, WsTrackerClearApiKeyRpc, WsOrchestrationDispatchCommandRpc, WsOrchestrationGetTurnDiffRpc, WsOrchestrationGetWorkflowScriptRpc, WsOrchestrationGetFullThreadDiffRpc, WsOrchestrationSearchThreadsRpc, WsOrchestrationGetArchivedShellSnapshotRpc, WsOrchestrationSubscribeShellRpc, WsOrchestrationSubscribeThreadRpc);
+const WsRpcGroup = RpcGroup.make(WsDeviceGetStateRpc, WsDeviceListRpc, WsDeviceConfigureRpc, WsDeviceOpenRpc, WsDeviceCloseRpc, WsDeviceDetailRpc, WsDeviceActionRpc, WsSubscribeDevicesRpc, WsServerProbeRpc, WsServerGetConfigRpc, WsServerRefreshProvidersRpc, WsServerProviderAuthStartRpc, WsServerProviderAuthCompleteRpc, WsServerProviderAuthCancelRpc, WsServerProviderAuthLogoutRpc, WsServerProviderAuthSubscribeRpc, WsServerProviderInstallStartRpc, WsServerProviderInstallCancelRpc, WsServerProviderInstallRemoveRpc, WsServerProviderInstallSubscribeRpc, WsServerUpdateProviderRpc, WsServerUpdateServerRpc, WsServerUpsertKeybindingRpc, WsServerRemoveKeybindingRpc, WsServerGetSettingsRpc, WsServerUpdateSettingsRpc, WsServerDiscoverSourceControlRpc, WsServerGetProviderUsageRpc, WsServerGetHostResourcesRpc, WsServerGetResourceTelemetryRpc, WsServerGetResourceTelemetryHistoryRpc, WsServerRetryResourceTelemetryRpc, WsSubscribeResourceTelemetryRpc, WsThreadHandoffRpc, WsBtwAskRpc, WsBtwCancelRpc, WsServerGetUsageSummaryRpc, WsServerGetTraceDiagnosticsRpc, WsServerGetProcessDiagnosticsRpc, WsServerGetProcessResourceHistoryRpc, WsServerSignalProcessRpc, WsPullRequestsListRpc, WsPullRequestsListStatsRpc, WsPullRequestsDetailRpc, WsPullRequestsStackRpc, WsPullRequestsActivityRpc, WsPullRequestsDiffFileContentsRpc, WsPullRequestsRunActionRpc, WsPullRequestsUpdateRpc, WsPullRequestsCommentRpc, WsPullRequestsUpdateCommentRpc, WsPullRequestsSubmitReviewRpc, WsPullRequestsReplyToThreadRpc, WsPullRequestsSetThreadResolutionRpc, WsPullRequestsSetReactionRpc, WsPullRequestsInvalidateRpc, WsPullRequestsReviewerCandidatesRpc, WsPullRequestsRequestReviewersRpc, WsSourceControlLookupRepositoryRpc, WsSourceControlCloneRepositoryRpc, WsSourceControlPublishRepositoryRpc, WsProjectsListEntriesRpc, WsProjectsReadFileRpc, WsProjectsSearchContentsRpc, WsProjectsSearchEntriesRpc, WsProjectsWriteFileRpc, WsShellOpenInEditorRpc, WsFilesystemBrowseRpc, WsAssetsCreateUrlRpc, WsSubscribeVcsStatusRpc, WsVcsPullRpc, WsVcsRefreshStatusRpc, WsGitRunStackedActionRpc, WsGitResolvePullRequestRpc, WsGitPreparePullRequestThreadRpc, WsVcsListRefsRpc, WsVcsCreateWorktreeRpc, WsVcsRemoveWorktreeRpc, WsVcsCreateRefRpc, WsVcsSwitchRefRpc, WsVcsInitRpc, WsReviewGetDiffPreviewRpc, WsTerminalOpenRpc, WsTerminalAttachRpc, WsTerminalWriteRpc, WsTerminalResizeRpc, WsTerminalClearRpc, WsTerminalRestartRpc, WsTerminalCloseRpc, WsSubscribeTerminalEventsRpc, WsSubscribeTerminalMetadataRpc, WsPreviewOpenRpc, WsPreviewNavigateRpc, WsPreviewResizeRpc, WsPreviewRefreshRpc, WsPreviewCloseRpc, WsPreviewListRpc, WsPreviewReportStatusRpc, WsComputerUseConnectRpc, WsComputerUseListRpc, WsComputerUseControlsRpc, WsComputerUseControlRpc, WsComputerUsePreviewRpc, WsComputerUseRespondRpc, WsPreviewAutomationConnectRpc, WsPreviewAutomationRespondRpc, WsPreviewAutomationFocusHostRpc, WsSubscribePreviewEventsRpc, WsSubscribeDiscoveredLocalServersRpc, WsSubscribeServerConfigRpc, WsSubscribeServerLifecycleRpc, WsSubscribeAuthAccessRpc, WsTasksListRpc, WsTasksGetRpc, WsTasksCreateRpc, WsTasksUpdateRpc, WsTasksDeleteRpc, WsTasksStartThreadRpc, WsFeedListRpc, WsFeedRefreshRpc, WsFeedSourcesListRpc, WsFeedSourcesUpsertRpc, WsFeedSourcesDeleteRpc, WsFeedMarkReadRpc, WsFeedCleanupRpc, WsSubscribeTasksRpc, WsHubGetSyncStatusRpc, WsHubConnectRpc, WsHubDisconnectRpc, WsHubSetSyncModeRpc, WsHubSetShareModeRpc, WsHubMintTokenRpc, WsSkillsSyncRpc, WsSkillsPublishRpc, WsSkillsPublishAllRpc, WsSkillsUnpublishRpc, WsAssetsReadRpc, WsAssetsSaveRpc, WsAssetsDeleteRpc, WsAssetsCreateLocalRpc, WsAssetsRemoveLocalRpc, WsSkillRegistrySearchRpc, WsSkillRegistryFetchRpc, WsMcpListRpc, WsMcpSaveRpc, WsMcpRemoveRpc, WsMcpSetSecretRpc, WsMcpOAuthBeginRpc, WsMcpOAuthDisconnectRpc, WsTrackerStatusRpc, WsTrackerSetApiKeyRpc, WsTrackerClearApiKeyRpc, WsOrchestrationDispatchCommandRpc, WsOrchestrationGetTurnDiffRpc, WsOrchestrationGetWorkflowScriptRpc, WsOrchestrationGetFullThreadDiffRpc, WsOrchestrationSearchThreadsRpc, WsOrchestrationGetArchivedShellSnapshotRpc, WsOrchestrationSubscribeShellRpc, WsOrchestrationSubscribeThreadRpc);
 //#endregion
 //#region ../../packages/shared/src/oauthScope.ts
 const OAUTH_SCOPE_TOKEN = /^[\u0021\u0023-\u005b\u005d-\u007e]+$/u;
@@ -24635,7 +24704,7 @@ const MAX_APNS_REQUEST_BYTES = 4096;
 const CLEANUP_TIMEOUT_MS$1 = 1e3;
 const MAX_REQUEST_BYTES$2 = 8 * 1024;
 const MAX_RESPONSE_BYTES$8 = 16 * 1024;
-const REQUEST_TIMEOUT_MS$6 = 8e3;
+const REQUEST_TIMEOUT_MS$7 = 8e3;
 const MAX_AUTH_CHARS = 8192;
 const unavailable$6 = () => ({
 	outcome: "retry",
@@ -24680,7 +24749,7 @@ const sendHubApns = Effect.fn("HubPushTransport.apns")(function* (input) {
 				finish(unavailable$6());
 				return;
 			}
-			timer = setTimeout(() => finish(unavailable$6()), REQUEST_TIMEOUT_MS$6);
+			timer = setTimeout(() => finish(unavailable$6()), REQUEST_TIMEOUT_MS$7);
 			session = NodeHttp2.connect(input.sandbox ? "https://api.sandbox.push.apple.com" : "https://api.push.apple.com", { maxHeaderListPairs: 32 });
 			session.on("error", () => finish(unavailable$6()));
 			session.on("close", () => finish(unavailable$6()));
@@ -24735,7 +24804,7 @@ const sendHubFcm = Effect.fn("HubPushTransport.fcm")(function* (input, fetcher =
 			const abort = () => owner.abort();
 			signal.addEventListener("abort", abort, { once: true });
 			if (signal.aborted) owner.abort();
-			const timeout = setTimeout(abort, REQUEST_TIMEOUT_MS$6);
+			const timeout = setTimeout(abort, REQUEST_TIMEOUT_MS$7);
 			let reader;
 			try {
 				const response = await fetcher(`https://fcm.googleapis.com/v1/projects/${input.projectId}/messages:send`, {
@@ -24776,7 +24845,7 @@ const sendHubFcm = Effect.fn("HubPushTransport.fcm")(function* (input, fetcher =
 			}
 		},
 		catch: () => unavailable$6()
-	}).pipe(Effect.timeout(REQUEST_TIMEOUT_MS$6), Effect.catch(() => Effect.succeed(unavailable$6())));
+	}).pipe(Effect.timeout(REQUEST_TIMEOUT_MS$7), Effect.catch(() => Effect.succeed(unavailable$6())));
 });
 //#endregion
 //#region src/hub/HubNotificationRuntime.ts
@@ -41682,6 +41751,72 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 		if (isPersistenceError(error)) return error;
 		return toPersistenceSqlError("ProjectionSnapshotQuery.getSnapshot:query")(error);
 	}));
+	const readHandoffThread = SqlSchema.findOneOption({
+		Request: ThreadIdLookupInput,
+		Result: ProjectionBtwThreadRowSchema,
+		execute: ({ threadId }) => sql`
+      SELECT threads.project_id AS "projectId",
+        COALESCE(projects.workspace_root, threads.worktree_path, '') AS cwd
+      FROM projection_threads AS threads
+      LEFT JOIN projection_projects AS projects ON projects.project_id = threads.project_id
+      WHERE threads.thread_id = ${threadId} AND threads.deleted_at IS NULL
+        AND (threads.project_id = ${P4_CHAT_PROJECT_ID} OR projects.deleted_at IS NULL)
+    `
+	});
+	const readHandoffRows = SqlSchema.findAll({
+		Request: ThreadIdLookupInput,
+		Result: Schema$1.Struct({
+			threadId: ThreadId,
+			role: Schema$1.String,
+			text: Schema$1.String
+		}),
+		execute: ({ threadId }) => sql`
+      WITH latest_pair AS (
+        SELECT implementer_thread_id, watcher_thread_id FROM thread_pairs
+        WHERE implementer_thread_id = ${threadId} OR watcher_thread_id = ${threadId}
+        ORDER BY created_at DESC LIMIT 1
+      ), sources AS (
+        SELECT ${threadId} AS id
+        UNION SELECT implementer_thread_id FROM latest_pair
+        UNION SELECT watcher_thread_id FROM latest_pair
+      ), ranked AS (
+        SELECT messages.thread_id AS "threadId", messages.role,
+          substr(messages.text, -${BTW_CONTEXT_CHARACTER_LIMIT}) AS text,
+          messages.created_at, messages.message_id,
+          ROW_NUMBER() OVER (PARTITION BY messages.thread_id ORDER BY messages.created_at DESC, messages.message_id DESC) AS recent,
+          ROW_NUMBER() OVER (PARTITION BY messages.thread_id ORDER BY messages.created_at, messages.message_id) AS earliest
+        FROM projection_thread_messages AS messages
+        JOIN projection_threads AS threads ON threads.thread_id = messages.thread_id
+        WHERE messages.thread_id IN (SELECT id FROM sources)
+          AND threads.deleted_at IS NULL AND messages.is_streaming = 0
+          AND messages.role IN ('user', 'assistant')
+      ) SELECT "threadId", role, text FROM ranked
+        WHERE recent <= ${BTW_CONTEXT_MESSAGE_LIMIT} OR earliest = 1
+        ORDER BY created_at, message_id
+    `
+	});
+	const getHandoffContext = Effect.fn("ProjectionSnapshotQuery.getHandoffContext")(function* (threadId) {
+		return yield* sql.withTransaction(Effect.gen(function* () {
+			const thread = yield* readHandoffThread({ threadId });
+			if (Option.isNone(thread)) return Option.none();
+			const rows = yield* readHandoffRows({ threadId });
+			const sourceIds = [...new Set(rows.map((row) => row.threadId))];
+			const sourceCount = Math.max(1, sourceIds.length);
+			const budget = Math.floor((BTW_CONTEXT_CHARACTER_LIMIT - 2 * (sourceCount - 1)) / sourceCount);
+			const transcript = sourceIds.map((sourceId) => {
+				const text = rows.filter((row) => row.threadId === sourceId).map((row) => `${row.role}: ${row.text}`).join("\n\n");
+				const heading = `Thread ${sourceId} (bounded history):\n`;
+				const available = budget - heading.length;
+				const omission = "\n[Earlier history omitted]\n";
+				const beginning = Math.floor(available / 4);
+				return heading + (text.length <= available ? text : text.slice(0, beginning) + omission + text.slice(-(available - beginning - 27)));
+			}).join("\n\n");
+			return Option.some({
+				...thread.value,
+				transcript
+			});
+		})).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getHandoffContext:query", "ProjectionSnapshotQuery.getHandoffContext:decodeRows")));
+	});
 	const getBtwContext = Effect.fn("ProjectionSnapshotQuery.getBtwContext")(function* (threadId) {
 		const [thread, rows] = yield* Effect.all([getBtwThreadRow({ threadId }), listBtwContextRows({ threadId })]).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getBtwContext:query", "ProjectionSnapshotQuery.getBtwContext:decodeRows")));
 		if (Option.isNone(thread)) return Option.none();
@@ -42265,6 +42400,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 		getThreadPairById,
 		getThreadShellById,
 		getThreadDetailById,
+		getHandoffContext,
 		getBtwContext,
 		getThreadDetailSnapshot
 	};
@@ -45373,7 +45509,7 @@ var DeviceDiscoveryFailure = class extends Data.TaggedError("DeviceDiscoveryFail
 const MAX_DEVICES = 512;
 const MAX_RESPONSE_BYTES$6 = 1024 * 1024;
 const MAX_DEVICE_LABEL = 512;
-const REQUEST_TIMEOUT_MS$5 = 15e3;
+const REQUEST_TIMEOUT_MS$6 = 15e3;
 const HubDevice = Schema$1.Struct({
 	id: DeviceId,
 	name: Schema$1.String.check(Schema$1.isMinLength(1), Schema$1.isMaxLength(MAX_DEVICE_LABEL)),
@@ -45416,7 +45552,10 @@ const make$87 = Effect.fn("DeviceDiscovery.make")(function* () {
 		});
 		if (body.invalidUtf8 || body.truncated) return yield* new DeviceDiscoveryFailure({ message: "Invalid device discovery response." });
 		const result = yield* decodeDeviceDiscovery(input.hostId, body.text);
-		const devices = [...result.devices];
+		const adapterDevices = input.ready.xcode ? yield* input.ready.xcode.discover : [];
+		const simulatorIds = new Set(adapterDevices.map((device) => device.id));
+		const devices = [...result.devices.filter((device) => device.platform !== "ios" || device.physical || !simulatorIds.has(device.id)), ...adapterDevices];
+		if (devices.length > MAX_DEVICES || new Set(devices.map((device) => device.id)).size !== devices.length || adapterDevices.some((device) => device.hostId !== input.hostId || device.platform !== "ios" || device.physical)) return yield* new DeviceDiscoveryFailure({ message: "Invalid Xcode simulator identity." });
 		if (input.androidAvailable) {
 			const avds = yield* input.ready.run("emulator", ["-list-avds"]);
 			if (avds.code !== 0) return yield* new DeviceDiscoveryFailure({ message: "Android virtual device discovery failed." });
@@ -45440,7 +45579,7 @@ const make$87 = Effect.fn("DeviceDiscovery.make")(function* () {
 			devices,
 			partial: result.partial
 		};
-	}, Effect.scoped, Effect.timeout(Duration.millis(REQUEST_TIMEOUT_MS$5)), Effect.mapError(() => new DeviceOperationError({
+	}, Effect.scoped, Effect.timeout(Duration.millis(REQUEST_TIMEOUT_MS$6)), Effect.mapError(() => new DeviceOperationError({
 		operation: "list",
 		reason: "request_failed",
 		cause: "Device discovery unavailable."
@@ -45744,6 +45883,675 @@ const start = Effect.fn("DeviceHostSettings.start")(function* (input) {
 	return { refresh };
 });
 //#endregion
+//#region src/device/DeviceScreenshot.ts
+const MAX_SCREENSHOT_BYTES = 8 * 1024 * 1024;
+var DeviceScreenshotFailure = class extends Data.TaggedError("DeviceScreenshotFailure") {};
+const MAX_DIMENSION = 16384;
+const MAX_PIXELS = 64 * 1024 * 1024;
+const SCREENSHOT_TIMEOUT_MS = 2e4;
+const PNG_HEADER_BYTES = 33;
+const PNG_CHUNK_OVERHEAD = 12;
+const PNG_SIGNATURE = Buffer.from([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+]);
+function pngDimensions(png) {
+	const buffer = Buffer.from(png.buffer, png.byteOffset, png.byteLength);
+	if (buffer.length < PNG_HEADER_BYTES || buffer.length > 8388608 || !buffer.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE) || buffer.readUInt32BE(8) !== 13 || buffer.toString("ascii", 12, 16) !== "IHDR") throw new DeviceScreenshotFailure({ message: "Invalid PNG screenshot." });
+	const width = buffer.readUInt32BE(16);
+	const height = buffer.readUInt32BE(20);
+	if (!width || !height || width > MAX_DIMENSION || height > MAX_DIMENSION || width * height > MAX_PIXELS) throw new DeviceScreenshotFailure({ message: "Screenshot dimensions exceed limits." });
+	let offset = PNG_HEADER_BYTES;
+	let imageData = false;
+	let ended = false;
+	while (offset + PNG_CHUNK_OVERHEAD <= buffer.length) {
+		const length = buffer.readUInt32BE(offset);
+		const type = buffer.toString("ascii", offset + 4, offset + 8);
+		const next = offset + PNG_CHUNK_OVERHEAD + length;
+		if (next > buffer.length || type === "IHDR") throw new DeviceScreenshotFailure({ message: "Invalid PNG chunk." });
+		if (type === "IDAT") imageData = true;
+		if (type === "IEND") {
+			ended = length === 0 && next === buffer.length;
+			break;
+		}
+		offset = next;
+	}
+	if (!imageData || !ended) throw new DeviceScreenshotFailure({ message: "Incomplete PNG screenshot." });
+	return {
+		width,
+		height
+	};
+}
+const make$82 = Effect.fn("DeviceScreenshot.make")(function* () {
+	const http = yield* HttpClient.HttpClient;
+	return Effect.fn("DeviceScreenshot.capture")(function* (ready, session) {
+		const origin = yield* Effect.try(() => new URL(ready.hub.origin));
+		if (origin.protocol !== "http:" || origin.hostname !== "127.0.0.1" || !origin.port || origin.username || origin.password || origin.pathname !== "/" || origin.search || origin.hash) return yield* new DeviceScreenshotFailure({ message: "Invalid owned hub." });
+		const vendor = session.platform === "ios" ? "serve-sim" : "serve-emu";
+		const response = yield* http.execute(HttpClientRequest.post(`${origin.origin}/vendor/${vendor}/api/screenshot?device=${encodeURIComponent(session.deviceId)}`));
+		if (response.status !== 200) return yield* new DeviceScreenshotFailure({ message: "Screenshot rejected." });
+		let bytes = 0;
+		const chunks = [];
+		yield* response.stream.pipe(Stream.runForEach((chunk) => Effect.gen(function* () {
+			bytes += chunk.byteLength;
+			if (bytes > 8388608) return yield* new DeviceScreenshotFailure({ message: "Screenshot too large." });
+			chunks.push(chunk);
+		})));
+		const png = Buffer.concat(chunks, bytes);
+		return {
+			png,
+			...yield* Effect.try(() => pngDimensions(png))
+		};
+	}, Effect.scoped, Effect.timeout(Duration.millis(SCREENSHOT_TIMEOUT_MS)), Effect.mapError(() => new DeviceOperationError({
+		operation: "screenshot",
+		reason: "request_failed",
+		cause: "Device screenshot could not be captured."
+	})));
+});
+var DeviceScreenshot = class extends Context.Service()("@p4code/cli/device/DeviceScreenshot") {};
+const layer$72 = Layer.effect(DeviceScreenshot, make$82().pipe(Effect.map((capture) => ({ capture }))));
+//#endregion
+//#region src/device/XcodeMcpClient.ts
+const XCODE_BUILD_MCP_VERSION = "2.7.0";
+const PROTOCOL_VERSION = "2025-06-18";
+const REQUEST_TIMEOUT_MS$5 = 6e4;
+const MAX_MESSAGE_BYTES = 12 * 1024 * 1024;
+const MAX_TOOL_PAGES = 32;
+function objectValue(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+/** One process per lease keeps semantic refs and simulator defaults isolated. Never invokes npx. */
+var XcodeMcpClient = class XcodeMcpClient {
+	child;
+	sequence = 0;
+	buffer = "";
+	closed = false;
+	pending = /* @__PURE__ */ new Map();
+	tools = /* @__PURE__ */ new Set();
+	constructor(child) {
+		this.child = child;
+		child.stdout.setEncoding("utf8");
+		child.stdout.on("data", (chunk) => {
+			this.buffer += chunk;
+			if (Buffer.byteLength(this.buffer) > MAX_MESSAGE_BYTES) {
+				this.close(/* @__PURE__ */ new Error("Device MCP response exceeds the supported size."));
+				return;
+			}
+			let boundary;
+			while ((boundary = this.buffer.indexOf("\n")) >= 0) {
+				const line = this.buffer.slice(0, boundary);
+				this.buffer = this.buffer.slice(boundary + 1);
+				try {
+					const message = objectValue(JSON.parse(line));
+					if (typeof message.id !== "number") continue;
+					const call = this.pending.get(message.id);
+					if (!call) continue;
+					this.pending.delete(message.id);
+					if (message.error) {
+						const detail = objectValue(message.error).message;
+						call.reject(new Error(typeof detail === "string" ? detail : "Device MCP request failed."));
+					} else call.resolve(message.result);
+				} catch {
+					this.close(/* @__PURE__ */ new Error("Device MCP returned invalid stdio JSON."));
+					return;
+				}
+			}
+		});
+		child.stderr.resume();
+		child.on("error", () => this.close(/* @__PURE__ */ new Error("Device MCP executable could not start.")));
+		child.on("exit", () => this.close(/* @__PURE__ */ new Error("Device MCP disconnected. Select the device again.")));
+		child.stdin.on("error", () => this.close(/* @__PURE__ */ new Error("Device MCP input disconnected.")));
+	}
+	static async start(executable, cwd, environment, signal, kind = "legacy") {
+		if (!isAbsolute(executable)) throw new Error("Device MCP requires an absolute executable path.");
+		await access(executable, constants.X_OK).catch(() => {
+			throw new Error(kind === "apple" ? "Selected Xcode bridge is missing or not executable. Check the selected Xcode installation." : "Configured XcodeBuildMCP executable is missing or not executable. Install 2.7.0 explicitly.");
+		});
+		signal.throwIfAborted();
+		const client = new XcodeMcpClient(spawn(executable, kind === "apple" ? ["mcpbridge"] : ["mcp"], {
+			cwd,
+			shell: false,
+			stdio: "pipe",
+			env: {
+				...environment,
+				...kind === "legacy" ? {
+					XCODEBUILDMCP_CWD: cwd,
+					XCODEBUILDMCP_DISABLE_SESSION_DEFAULTS: "true",
+					XCODEBUILDMCP_ENABLED_WORKFLOWS: "simulator,ui-automation",
+					XCODEBUILDMCP_SENTRY_DISABLED: "true"
+				} : {}
+			}
+		}));
+		try {
+			const initialized = objectValue(await client.request("initialize", {
+				protocolVersion: PROTOCOL_VERSION,
+				capabilities: {},
+				clientInfo: {
+					name: "p4code-device-adapter",
+					version: "1"
+				}
+			}, signal));
+			if (kind === "apple" && objectValue(initialized.serverInfo).name !== "xcode-tools") throw new Error("Selected Xcode did not expose Apple MCP tools.");
+			if (kind === "legacy" && objectValue(initialized.serverInfo).version !== "2.7.0") throw new Error(`P4 requires XcodeBuildMCP ${XCODE_BUILD_MCP_VERSION}; configured executable reported a different version.`);
+			client.child.stdin.write(JSON.stringify({
+				jsonrpc: "2.0",
+				method: "notifications/initialized"
+			}) + "\n");
+			let cursor;
+			const cursors = /* @__PURE__ */ new Set();
+			do {
+				const page = objectValue(await client.request("tools/list", cursor ? { cursor } : {}, signal));
+				if (!Array.isArray(page.tools)) throw new Error("Device MCP did not advertise tools.");
+				for (const tool of page.tools) {
+					const name = objectValue(tool).name;
+					if (typeof name === "string") client.tools.add(name);
+				}
+				cursor = page.nextCursor;
+				if (typeof cursor === "string" && cursor.length > 0) {
+					if (cursors.has(cursor) || cursors.size >= MAX_TOOL_PAGES) throw new Error("Device MCP tool discovery did not finish within its page limit.");
+					cursors.add(cursor);
+				}
+			} while (typeof cursor === "string" && cursor.length > 0);
+			return client;
+		} catch (error) {
+			client.close();
+			throw error;
+		}
+	}
+	request(method, params, signal) {
+		signal.throwIfAborted();
+		if (this.closed) return Promise.reject(/* @__PURE__ */ new Error("Device MCP session is closed. Select the device again."));
+		const id = ++this.sequence;
+		return new Promise((resolve, reject) => {
+			const abort = () => this.close(/* @__PURE__ */ new Error("Device MCP request cancelled. Select the device again."));
+			const timer = setTimeout(() => this.close(/* @__PURE__ */ new Error("Device MCP timed out. Select the device again.")), REQUEST_TIMEOUT_MS$5);
+			const finish = () => {
+				clearTimeout(timer);
+				signal.removeEventListener("abort", abort);
+			};
+			this.pending.set(id, {
+				resolve: (result) => {
+					finish();
+					resolve(result);
+				},
+				reject: (error) => {
+					finish();
+					reject(error);
+				}
+			});
+			signal.addEventListener("abort", abort, { once: true });
+			this.child.stdin.write(JSON.stringify({
+				jsonrpc: "2.0",
+				id,
+				method,
+				params
+			}) + "\n");
+		});
+	}
+	async call(name, args, signal) {
+		if (!this.tools.has(name)) throw new Error(`Selected device MCP service does not expose ${name}. Check adapter capabilities and Xcode setup.`);
+		const redact = (error) => {
+			let message = error instanceof Error ? error.message : String(error);
+			for (const [key, value] of Object.entries(args)) if (/sessionkey$/i.test(key) && typeof value === "string" && value.length > 0) message = message.replaceAll(value, "[redacted]");
+			return new Error(message);
+		};
+		try {
+			const result = objectValue(await this.request("tools/call", {
+				name,
+				arguments: args
+			}, signal));
+			const structured = objectValue(result.structuredContent);
+			if (result.isError === true || structured.didError === true) {
+				const detail = (Array.isArray(result.content) ? result.content : []).map((part) => objectValue(part).text).filter((part) => typeof part === "string").join("\n");
+				throw new Error(detail || String(structured.error ?? `${name} failed. Refresh device state before retrying.`));
+			}
+			return result;
+		} catch (error) {
+			throw redact(error);
+		}
+	}
+	close(error = /* @__PURE__ */ new Error("Device MCP session closed.")) {
+		if (this.closed) return;
+		this.closed = true;
+		for (const call of this.pending.values()) call.reject(error);
+		this.pending.clear();
+		this.child.kill("SIGTERM");
+	}
+};
+//#endregion
+//#region src/device/XcodeDeviceAdapter.ts
+const SimulatorList = Schema$1.Struct({ simulators: Schema$1.Array(Schema$1.Struct({
+	simulatorId: Schema$1.String,
+	name: Schema$1.String,
+	runtime: Schema$1.String,
+	state: Schema$1.String,
+	isAvailable: Schema$1.Boolean
+})) });
+const decodeSimulators = Schema$1.decodeUnknownSync(SimulatorList);
+const MAX_LEASES = 32;
+const Frame = Schema$1.Struct({
+	x: Schema$1.Number,
+	y: Schema$1.Number,
+	width: Schema$1.Number,
+	height: Schema$1.Number
+});
+const Snapshot = Schema$1.Struct({ elements: Schema$1.Array(Schema$1.Struct({
+	ref: Schema$1.String,
+	role: Schema$1.optional(Schema$1.String),
+	frame: Frame
+})) });
+const readSnapshot = Schema$1.decodeUnknownOption(Snapshot);
+/** Retain structured semantic snapshots; callers never need screenshot round trips for refs. */
+function xcodeResultData(result) {
+	const structured = objectValue(result.structuredContent);
+	return objectValue(structured.data ?? structured);
+}
+function createXcodeDeviceAdapter(executable, cwd, environment) {
+	const clients = /* @__PURE__ */ new Map();
+	const recordings = /* @__PURE__ */ new Map();
+	const snapshots = /* @__PURE__ */ new Map();
+	const remember = (session, data) => {
+		const snapshot = readSnapshot(data.capture);
+		if (snapshot._tag === "Some") snapshots.set(session.leaseId, snapshot.value);
+		const viewport = snapshots.get(session.leaseId)?.elements.find((element) => element.role === "window")?.frame;
+		return {
+			...data,
+			...viewport ? { viewport } : {}
+		};
+	};
+	const get = async (key, signal) => {
+		let pending = clients.get(key);
+		if (!pending) {
+			if (clients.size >= MAX_LEASES) throw new Error("Close an existing Xcode device session before opening another.");
+			pending = XcodeMcpClient.start(executable, cwd, environment, signal);
+			clients.set(key, pending);
+			pending.catch(() => {
+				if (clients.get(key) === pending) clients.delete(key);
+			});
+		}
+		return pending;
+	};
+	const run = (operation, execute) => Effect.tryPromise({
+		try: execute,
+		catch: (cause) => new DeviceOperationError({
+			operation,
+			reason: "request_failed",
+			cause: cause instanceof Error ? cause.message : String(cause)
+		})
+	});
+	const forSession = async (session, signal) => {
+		if (session.hostId !== "local" || session.platform !== "ios" || !session.leaseId) throw new Error("Xcode adapter requires an exact local iOS Simulator lease.");
+		return get(session.leaseId, signal);
+	};
+	const closeSession = (leaseId) => {
+		const client = clients.get(leaseId);
+		clients.delete(leaseId);
+		const recording = recordings.get(leaseId);
+		recordings.delete(leaseId);
+		snapshots.delete(leaseId);
+		client?.then(async (client) => {
+			try {
+				if (recording) await client.call("record_sim_video", {
+					...recording,
+					stop: true
+				}, new AbortController().signal);
+			} finally {
+				client.close();
+			}
+		}).catch(() => {});
+	};
+	return {
+		discover: run("list", async (signal) => {
+			const client = await get("discovery", signal);
+			return decodeSimulators(xcodeResultData(await client.call("list_sims", {}, signal))).simulators.filter((sim) => sim.isAvailable && /iOS/i.test(sim.runtime)).map((sim) => ({
+				id: sim.simulatorId,
+				hostId: "local",
+				name: sim.name,
+				version: sim.runtime,
+				booted: sim.state === "Booted",
+				physical: false,
+				platform: "ios"
+			}));
+		}),
+		state: (session, sinceScreenHash) => run("state", async (signal) => {
+			const client = await forSession(session, signal);
+			const data = xcodeResultData(await client.call("snapshot_ui", {
+				simulatorId: session.deviceId,
+				...sinceScreenHash ? { sinceScreenHash } : {}
+			}, signal));
+			return {
+				adapter: "xcodebuildmcp",
+				capabilities: [...client.tools].filter((tool) => [
+					"tap",
+					"type_text",
+					"swipe",
+					"drag",
+					"batch",
+					"snapshot_ui",
+					"screenshot",
+					"record_sim_video"
+				].includes(tool)),
+				...remember(session, data)
+			};
+		}),
+		action: (session, input) => run("command", async (signal) => {
+			const client = await forSession(session, signal);
+			const { action, ...parameters } = input;
+			const snapshot = snapshots.get(session.leaseId);
+			const ref = input.action === "batch" ? input.steps.at(-1)?.elementRef : input.action === "swipe" ? input.withinElementRef : input.elementRef;
+			const bounds = snapshot?.elements.find((element) => element.ref === ref)?.frame;
+			const viewport = snapshot?.elements.find((element) => element.role === "window")?.frame;
+			const data = xcodeResultData(await client.call(action, {
+				...parameters,
+				simulatorId: session.deviceId
+			}, signal));
+			return {
+				...remember(session, data),
+				...bounds && viewport && viewport.width > 0 && viewport.height > 0 ? { pointer: {
+					x: (bounds.x + bounds.width / 2 - viewport.x) / viewport.width,
+					y: (bounds.y + bounds.height / 2 - viewport.y) / viewport.height
+				} } : {}
+			};
+		}),
+		screenshot: (session) => run("screenshot", async (signal) => {
+			const result = await (await forSession(session, signal)).call("screenshot", {
+				simulatorId: session.deviceId,
+				returnFormat: "base64"
+			}, signal);
+			const image = (Array.isArray(result.content) ? result.content : []).map(objectValue).find((part) => part.type === "image" && part.mimeType === "image/png");
+			if (typeof image?.data !== "string") throw new Error("XcodeBuildMCP did not return a PNG screenshot.");
+			const png = Buffer.from(image.data, "base64");
+			return {
+				png,
+				...pngDimensions(png)
+			};
+		}),
+		recording: (session, action) => run("recording", async (signal) => {
+			const client = await forSession(session, signal);
+			const key = session.leaseId;
+			if (action === "start" && recordings.has(key)) throw new Error("This device session is already recording.");
+			if (action === "stop" && !recordings.has(key)) throw new Error("This device session has no active recording.");
+			const outputFile = recordings.get(key)?.outputFile ?? `${cwd}/device-recording-${randomUUID()}.mp4`;
+			const result = xcodeResultData(await client.call("record_sim_video", {
+				simulatorId: session.deviceId,
+				...action === "start" ? { start: true } : {
+					stop: true,
+					outputFile
+				}
+			}, signal));
+			if (action === "start") recordings.set(key, {
+				outputFile,
+				simulatorId: session.deviceId
+			});
+			else recordings.delete(key);
+			return result;
+		}),
+		closeSession,
+		stop: () => {
+			for (const key of clients.keys()) closeSession(key);
+		}
+	};
+}
+//#endregion
+//#region src/device/AppleDeviceAdapter.ts
+const MAX_HIERARCHY_BYTES = 512 * 1024;
+const MAX_SESSIONS = 32;
+const REQUIRED_DEVICE_TOOLS = [
+	"DeviceInteractionStartSession",
+	"DeviceInteractionSynthesize",
+	"DeviceInteractionEndSession"
+];
+const FRAME_PATTERN = /\{\{(-?[\d.]+),\s*(-?[\d.]+)\},\s*\{([\d.]+),\s*([\d.]+)\}\}/;
+const HIT_PATTERN = /hitPoint:\s*\{(-?[\d.]+),\s*(-?[\d.]+)\}/;
+const Capture = Schema$1.Struct({
+	hierarchyPath: Schema$1.String,
+	screenshotPath: Schema$1.String
+});
+const Session = Schema$1.Struct({
+	interactionSessionKey: Schema$1.String,
+	deviceUUID: Schema$1.String,
+	deviceIsSimulator: Schema$1.Boolean
+});
+const Simulators = Schema$1.Struct({ devices: Schema$1.Record(Schema$1.String, Schema$1.Array(Schema$1.Struct({
+	udid: Schema$1.String,
+	name: Schema$1.String,
+	state: Schema$1.String,
+	isAvailable: Schema$1.Boolean
+}))) });
+function appleMcpData(result) {
+	if (result.structuredContent) return objectValue(result.structuredContent);
+	for (const block of Array.isArray(result.content) ? result.content : []) {
+		const text = objectValue(block).text;
+		if (typeof text !== "string") continue;
+		try {
+			return objectValue(JSON.parse(text));
+		} catch {}
+	}
+	throw new Error("Apple MCP returned no structured device result.");
+}
+/** Use Apple's documented hierarchy hit points, never guessed screenshot coordinates. */
+function appleHierarchySnapshot(text, sequence) {
+	const elements = text.split("\n").flatMap((line, index) => {
+		const frame = line.match(FRAME_PATTERN);
+		const hit = line.match(HIT_PATTERN);
+		if (!frame || !hit || line.includes("isRemoteLeafPlaceholder")) return [];
+		const [x, y, width, height] = frame.slice(1).map(Number);
+		const [hx, hy] = hit.slice(1).map(Number);
+		if (![
+			x,
+			y,
+			width,
+			height,
+			hx,
+			hy
+		].every((value) => value !== void 0 && Number.isFinite(value)) || width <= 0 || height <= 0) return [];
+		return [{
+			ref: `a${sequence}-${index}`,
+			label: line.trim(),
+			frame: {
+				x,
+				y,
+				width,
+				height
+			},
+			hitPoint: {
+				x: hx,
+				y: hy
+			},
+			role: /\b(?:UI)?Window\b/.test(line) ? "window" : "element",
+			actions: ["tap"]
+		}];
+	});
+	return {
+		screenHash: createHash("sha256").update(text).digest("hex"),
+		seq: sequence,
+		elements
+	};
+}
+function createAppleDeviceAdapter(input) {
+	const sessions = /* @__PURE__ */ new Map();
+	const fail = (operation) => (cause) => new DeviceOperationError({
+		operation,
+		reason: "request_failed",
+		cause: cause instanceof Error ? cause.message : String(cause)
+	});
+	const call = (client, name, args) => Effect.tryPromise({
+		try: (signal) => client.call(name, args, signal),
+		catch: fail(name)
+	});
+	const closeSession = (leaseId) => {
+		const pending = sessions.get(leaseId);
+		sessions.delete(leaseId);
+		pending?.then(async (owned) => {
+			try {
+				await owned.client.call("DeviceInteractionEndSession", { interactionSessionKey: owned.key }, new AbortController().signal);
+			} finally {
+				owned.client.close();
+			}
+		}).catch(() => {});
+	};
+	const get = (session) => Effect.tryPromise({
+		try: async (signal) => {
+			if (session.hostId !== "local" || session.platform !== "ios" || !session.leaseId) throw new Error("Apple MCP requires an exact local iOS device lease.");
+			let pending = sessions.get(session.leaseId);
+			if (!pending) {
+				if (sessions.size >= MAX_SESSIONS) throw new Error("Close an existing device session first.");
+				pending = (async () => {
+					const client = await XcodeMcpClient.start("/usr/bin/xcrun", input.cwd, {
+						...input.environment,
+						MCP_XCODE_SESSION_ID: randomUUID()
+					}, signal, "apple");
+					try {
+						const missing = REQUIRED_DEVICE_TOOLS.filter((tool) => !client.tools.has(tool));
+						if (missing.length > 0) throw new Error(`Selected Xcode lacks required device tools: ${missing.join(", ")}. No device session was opened.`);
+						if (input.workspacePath) await client.call("XcodeOpenWorkspace", { path: input.workspacePath }, signal);
+						const opened = Schema$1.decodeUnknownSync(Session)(appleMcpData(await client.call("DeviceInteractionStartSession", {
+							deviceIdentifier: session.deviceId,
+							sessionIdentifier: `P4 Device ${session.threadId.slice(0, 8)}`
+						}, signal)));
+						if (opened.deviceUUID.toLowerCase() !== session.deviceId.toLowerCase() || !opened.deviceIsSimulator) {
+							await client.call("DeviceInteractionEndSession", { interactionSessionKey: opened.interactionSessionKey }, signal);
+							throw new Error("Apple selected a different device. No interaction was performed.");
+						}
+						return {
+							client,
+							key: opened.interactionSessionKey,
+							sequence: 0
+						};
+					} catch (error) {
+						client.close();
+						throw error;
+					}
+				})();
+				sessions.set(session.leaseId, pending);
+				const leaseId = session.leaseId;
+				pending.catch(() => {
+					if (sessions.get(leaseId) === pending) sessions.delete(leaseId);
+				});
+			}
+			return pending;
+		},
+		catch: fail("open")
+	});
+	const capture = (owned, interactionCommand) => Effect.gen(function* () {
+		const response = yield* call(owned.client, "DeviceInteractionSynthesize", {
+			interactSessionKey: owned.key,
+			...interactionCommand ? { interactionCommand } : {}
+		});
+		const data = yield* Effect.try({
+			try: () => appleMcpData(response),
+			catch: fail("state")
+		});
+		const result = yield* Schema$1.decodeUnknownEffect(Capture)(data);
+		if ((yield* input.fs.stat(result.hierarchyPath)).size > BigInt(MAX_HIERARCHY_BYTES)) return yield* fail("state")("Apple hierarchy exceeds the supported size.");
+		const snapshot = appleHierarchySnapshot(yield* input.fs.readFileString(result.hierarchyPath), owned.sequence + 1);
+		if (owned.snapshot?.screenHash !== snapshot.screenHash) {
+			owned.snapshot = snapshot;
+			owned.sequence += 1;
+		}
+		const currentSnapshot = owned.snapshot;
+		owned.image = result.screenshotPath;
+		const viewport = currentSnapshot.elements.find((element) => element.role === "window")?.frame;
+		return {
+			adapter: "apple-xcode",
+			capabilities: [
+				"snapshot_ui",
+				"tap",
+				"screenshot"
+			],
+			capture: currentSnapshot,
+			...viewport ? { viewport } : {}
+		};
+	}).pipe(Effect.mapError(fail("state")));
+	return {
+		diagnose: Effect.gen(function* () {
+			const result = yield* input.run("xcrun", [
+				"mcp-server",
+				"status",
+				"--format",
+				"json"
+			]);
+			if (result.code !== 0) return "Apple MCP did not respond. Check the selected Xcode installation and MCP service.";
+			const status = objectValue(yield* Schema$1.decodeUnknownEffect(Schema$1.UnknownFromJsonString)(result.stdout));
+			const permission = objectValue(status.permission);
+			if ((Array.isArray(permission.pendingAgentApprovals) ? permission.pendingAgentApprovals : []).some((item) => objectValue(objectValue(objectValue(objectValue(item).subject).agent)._0).name === "p4code-device-adapter")) return "Apple Xcode is waiting for approval of p4code-device-adapter and its project folder. Approve the pending request in Xcode, then select the device again. P4 cannot grant this approval automatically.";
+			if (status.running === false) return "Apple MCP service is not running. Open the selected Xcode project or configure its headless service, then select the device again.";
+			return "Apple MCP did not respond in time. Check Xcode agent/folder permissions and session logs before selecting the device again.";
+		}).pipe(Effect.orElseSucceed(() => "Apple MCP did not respond. Check Xcode agent/folder permissions and service status.")),
+		discover: Effect.gen(function* () {
+			const result = yield* input.run("xcrun", [
+				"simctl",
+				"list",
+				"devices",
+				"available",
+				"--json"
+			]);
+			if (result.code !== 0) return yield* fail("list")("Selected Xcode cannot list simulators.");
+			const parsed = yield* Schema$1.decodeUnknownEffect(Schema$1.fromJsonString(Simulators))(result.stdout).pipe(Effect.mapError(fail("list")));
+			return Object.entries(parsed.devices).filter(([runtime]) => runtime.includes(".iOS-")).flatMap(([runtime, devices]) => devices.filter((device) => device.isAvailable).map((device) => ({
+				hostId: "local",
+				id: device.udid,
+				platform: "ios",
+				name: device.name,
+				version: runtime.replace("com.apple.CoreSimulator.SimRuntime.", "").replaceAll("-", "."),
+				physical: false,
+				booted: device.state === "Booted"
+			})));
+		}),
+		state: (session, sinceScreenHash) => Effect.gen(function* () {
+			const result = yield* capture(yield* get(session));
+			return sinceScreenHash === result.capture.screenHash ? {
+				...result,
+				capture: {
+					screenHash: result.capture.screenHash,
+					seq: result.capture.seq,
+					unchanged: true
+				}
+			} : result;
+		}),
+		action: (session, action) => Effect.gen(function* () {
+			if (action.action !== "tap") return yield* fail("command")("This Apple MCP integration currently advertises tap only. Use only capabilities returned by getAXState().");
+			const owned = yield* get(session);
+			const previous = owned.snapshot;
+			const element = previous?.elements.find((element) => element.ref === action.elementRef);
+			if (!element) return yield* fail("command")("Stale device ref. Read getAXState() and choose a current element.");
+			const fresh = yield* capture(owned);
+			if (fresh.capture.screenHash !== previous.screenHash) return yield* fail("command")("Device layout changed. Read getAXState() and choose a current element; no action was performed.");
+			return {
+				...yield* capture(owned, `t ${element.hitPoint.x} ${element.hitPoint.y}`),
+				...fresh.viewport ? { pointer: {
+					x: (element.hitPoint.x - fresh.viewport.x) / fresh.viewport.width,
+					y: (element.hitPoint.y - fresh.viewport.y) / fresh.viewport.height
+				} } : {}
+			};
+		}),
+		screenshot: (session) => Effect.gen(function* () {
+			const owned = yield* get(session);
+			yield* capture(owned);
+			if ((yield* input.fs.stat(owned.image)).size > BigInt(8388608)) return yield* fail("screenshot")("Apple screenshot exceeds the supported size.");
+			const png = Buffer.from(yield* input.fs.readFile(owned.image));
+			return {
+				png,
+				...yield* Effect.try({
+					try: () => pngDimensions(png),
+					catch: fail("screenshot")
+				})
+			};
+		}).pipe(Effect.mapError(fail("screenshot"))),
+		recording: (_session, _action) => Effect.fail(fail("recording")("Apple MCP does not advertise a recording tool. Recording is unavailable through this adapter.")),
+		closeSession,
+		stop: () => {
+			for (const key of sessions.keys()) closeSession(key);
+		}
+	};
+}
+//#endregion
 //#region src/device/DeviceToolchain.ts
 /**
 * Pinned installs of the two external tools device support is built on.
@@ -45959,7 +46767,8 @@ function deviceHubPlatform(platforms) {
 const COMMAND_TIMEOUT_MS$1 = 2e4;
 const COMMAND_OUTPUT_LIMIT = 1024 * 1024;
 const COMMAND_FAILURE_CODE = 127;
-const make$82 = Effect.fn("LocalDeviceHost.make")(function* () {
+const APPLE_DEVICE_MCP_MINIMUM_XCODE = 27;
+const make$81 = Effect.fn("LocalDeviceHost.make")(function* () {
 	const config = yield* ServerConfig$1;
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path$1.Path;
@@ -46005,7 +46814,19 @@ const make$82 = Effect.fn("LocalDeviceHost.make")(function* () {
 		stderr: "Device command failed.",
 		code: COMMAND_FAILURE_CODE
 	})));
+	const appleVersion = (platform === "darwin" ? yield* run("xcrun", ["--find", "mcpbridge"]) : null)?.code === 0 ? yield* run("xcodebuild", ["-version"]) : null;
+	const appleAvailable = appleVersion?.code === 0 && Number(appleVersion.stdout.match(/^Xcode (\d+)\b/m)?.[1]) >= APPLE_DEVICE_MCP_MINIMUM_XCODE;
+	const legacyPath = environment.P4CODE_XCODEBUILDMCP_PATH?.trim();
+	const useLegacy = environment.P4CODE_DEVICE_ADAPTER === "xcodebuildmcp";
+	const xcode = appleAvailable && !useLegacy ? createAppleDeviceAdapter({
+		cwd: config.stateDir,
+		environment: hostEnvironment,
+		fs,
+		run,
+		...environment.P4CODE_APPLE_MCP_WORKSPACE ? { workspacePath: environment.P4CODE_APPLE_MCP_WORKSPACE } : {}
+	}) : platform === "darwin" && legacyPath ? createXcodeDeviceAdapter(legacyPath, config.stateDir, hostEnvironment) : void 0;
 	const stopAgent = Effect.suspend(() => {
+		xcode?.stop();
 		const owned = agent;
 		agent = null;
 		return owned?.stop ?? Effect.void;
@@ -46044,7 +46865,8 @@ const make$82 = Effect.fn("LocalDeviceHost.make")(function* () {
 			nodePath: process.execPath,
 			hub: { origin: started.origin },
 			helpers,
-			run
+			run,
+			...xcode ? { xcode } : {}
 		};
 		return ready;
 	}, Effect.onExit((exit) => Exit.isFailure(exit) ? stop : Effect.void));
@@ -46055,6 +46877,10 @@ const make$82 = Effect.fn("LocalDeviceHost.make")(function* () {
 				id: hostId,
 				kind: "local",
 				label: "This machine",
+				...xcode ? { automation: {
+					provider: appleAvailable && !useLegacy ? "apple-xcode" : "xcodebuildmcp",
+					detail: appleAvailable && !useLegacy ? "Apple Xcode MCP. Agent and folder approval is required; P4 never grants it automatically." : "Optional XcodeBuildMCP 2.7.0 executable. No automatic installation."
+				} } : {},
 				platforms: yield* Effect.all([platformAvailability("ios"), platformAvailability("android")]),
 				hubInstalled: yield* isDeviceHubInstalled(config.baseDir).pipe(Effect.provideContext(context)),
 				agentDeviceInstalled: yield* isAgentDeviceInstalled(config.baseDir).pipe(Effect.provideContext(context))
@@ -46066,8 +46892,9 @@ const make$82 = Effect.fn("LocalDeviceHost.make")(function* () {
 			return ready;
 		})),
 		ensureReady: (onPhase) => lock.withPermit(ensureHub(onPhase)),
-		ensureAgentReady: (onPhase) => lock.withPermit(Effect.gen(function* () {
+		ensureAgentReady: (onPhase, devicePlatform) => lock.withPermit(Effect.gen(function* () {
 			const host = yield* ensureHub(onPhase);
+			if (xcode && devicePlatform === "ios") return host;
 			if (agent && (yield* agent.isRunning)) return {
 				...host,
 				agentDevice: agent.endpoint
@@ -46094,7 +46921,7 @@ const make$82 = Effect.fn("LocalDeviceHost.make")(function* () {
 		stop: lock.withPermit(stop)
 	};
 });
-Layer.effect(DeviceHost, make$82()).pipe(Layer.provide(layer$73));
+Layer.effect(DeviceHost, make$81()).pipe(Layer.provide(layer$73));
 Data.TaggedError("SshHostDiscoveryError");
 var SshInvalidTargetError = class extends Data.TaggedError("SshInvalidTargetError") {};
 var SshCommandError = class extends Data.TaggedError("SshCommandError") {};
@@ -46953,7 +47780,7 @@ const probeSshDeviceHost = Effect.fn("SshDeviceDiagnostics.probe")(function* (co
 //#endregion
 //#region src/device/SshDeviceHost.ts
 const DIAGNOSTICS_CACHE_MS = 1e4;
-const make$81 = Effect.fn("SshDeviceHost.make")(function* (input) {
+const make$80 = Effect.fn("SshDeviceHost.make")(function* (input) {
 	const config = yield* Schema$1.decodeUnknownEffect(SshDeviceHostConfig)({ ...input }).pipe(Effect.mapError(() => new DeviceHostError({
 		hostId: input.id,
 		step: "configuring SSH device host",
@@ -47095,6 +47922,14 @@ const makeWithHosts = Effect.fn("DeviceService.makeWithHosts")(function* (input)
 	const scope = yield* Scope.Scope;
 	const registry = yield* make$83(input);
 	const commands = yield* make$85();
+	const adapterLeases = /* @__PURE__ */ new Map();
+	const closeCommands = (sessions) => Effect.sync(() => {
+		for (const session of sessions) {
+			if (!session.leaseId) continue;
+			adapterLeases.get(session.leaseId)?.();
+			adapterLeases.delete(session.leaseId);
+		}
+	}).pipe(Effect.andThen(commands.close(sessions)));
 	const threads = yield* make$84();
 	const changes = yield* Effect.acquireRelease(PubSub.sliding(STATE_BUFFER_SIZE), PubSub.shutdown);
 	const stateLock = yield* Semaphore.make(1);
@@ -47132,7 +47967,7 @@ const makeWithHosts = Effect.fn("DeviceService.makeWithHosts")(function* (input)
 		}));
 	}
 	const retireSessions = (ids) => Effect.gen(function* () {
-		yield* commands.close(state.sessions.filter((session) => ids.includes(session.hostId)));
+		yield* closeCommands(state.sessions.filter((session) => ids.includes(session.hostId)));
 		yield* update((current) => {
 			for (const id of ids) hostLocks.delete(id);
 			return {
@@ -47343,7 +48178,7 @@ const makeWithHosts = Effect.fn("DeviceService.makeWithHosts")(function* (input)
 		return yield* withHost(value.hostId, (lease) => Effect.gen(function* () {
 			let found = yield* freshDevice(lease, value);
 			if (access === "agent") {
-				yield* lease.host.ensureAgentReady(() => Effect.void);
+				yield* lease.host.ensureAgentReady(() => Effect.void, value.platform);
 				yield* registry.commit(lease, () => void 0);
 			}
 			if (!found.device.booted && value.boot !== false) {
@@ -47382,7 +48217,7 @@ const makeWithHosts = Effect.fn("DeviceService.makeWithHosts")(function* (input)
 				openedAt,
 				leaseId: NodeCrypto.randomUUID()
 			};
-			yield* commands.close(sessionsToClose(state.sessions, session));
+			yield* closeCommands(sessionsToClose(state.sessions, session));
 			yield* update((current) => ({
 				...current,
 				sessions: [...current.sessions.filter((item) => !(item.threadId === session.threadId && item.hostId === session.hostId && item.deviceId === session.deviceId)), session]
@@ -47393,7 +48228,7 @@ const makeWithHosts = Effect.fn("DeviceService.makeWithHosts")(function* (input)
 	const shutdownWithin = Effect.fn("DeviceService.shutdownWithin")(function* (lease, value) {
 		const { ready, device } = yield* freshDevice(lease, value);
 		yield* input.actions.shutdown(ready, device);
-		yield* commands.close(state.sessions.filter((session) => session.hostId === value.hostId && session.deviceId === value.deviceId));
+		yield* closeCommands(state.sessions.filter((session) => session.hostId === value.hostId && session.deviceId === value.deviceId));
 		yield* update((current) => ({
 			...current,
 			devices: current.devices.map((item) => item.hostId === value.hostId && item.id === value.deviceId ? {
@@ -47417,7 +48252,7 @@ const makeWithHosts = Effect.fn("DeviceService.makeWithHosts")(function* (input)
 				platform: session.platform
 			});
 			else {
-				yield* commands.close(sessionsToClose(state.sessions, value));
+				yield* closeCommands(sessionsToClose(state.sessions, value));
 				yield* update((current) => {
 					const closing = sessionsToClose(current.sessions, value);
 					return {
@@ -47460,11 +48295,16 @@ const makeWithHosts = Effect.fn("DeviceService.makeWithHosts")(function* (input)
 			});
 			const validate = registry.isCurrent(lease).pipe(Effect.map((current) => current && state.sessions.includes(session)));
 			return yield* commands.run(session, validate, Effect.gen(function* () {
-				const ready = yield* lease.host.ensureAgentReady(() => Effect.void);
+				const ready = yield* lease.host.ensureAgentReady(() => Effect.void, session.platform);
 				if (!(yield* validate)) return yield* new DeviceHostUnavailableError({
 					hostId: target.hostId,
 					reason: "Device session or agent authorization changed."
 				});
+				if (ready.xcode && session.leaseId) {
+					const adapter = ready.xcode;
+					const leaseId = session.leaseId;
+					adapterLeases.set(leaseId, () => adapter.closeSession(leaseId));
+				}
 				return yield* execute(ready, session);
 			}));
 		})).pipe(Effect.mapError((error) => isDeviceHostError(error) || isDeviceHostTimeoutError(error) ? new DeviceHostUnavailableError({
@@ -47478,7 +48318,7 @@ const makeWithHosts = Effect.fn("DeviceService.makeWithHosts")(function* (input)
 		agentList: listForAccess("agent"),
 		configure,
 		shutdown,
-		retireThread: (threadId) => threads.retire(threadId).pipe(Effect.ensuring(Effect.suspend(() => commands.close(state.sessions.filter((session) => session.threadId === threadId))).pipe(Effect.ensuring(update((current) => ({
+		retireThread: (threadId) => threads.retire(threadId).pipe(Effect.ensuring(Effect.suspend(() => closeCommands(state.sessions.filter((session) => session.threadId === threadId))).pipe(Effect.ensuring(update((current) => ({
 			...current,
 			sessions: current.sessions.filter((session) => session.threadId !== threadId),
 			bootingDevices: (current.bootingDevices ?? []).filter((device) => device.threadId !== threadId)
@@ -47486,7 +48326,10 @@ const makeWithHosts = Effect.fn("DeviceService.makeWithHosts")(function* (input)
 		restoreThread: threads.restore,
 		withAgentDevice: (target, execute) => threads.run(target.threadId, withAgentDevice(target, execute)),
 		withManualDevice: (target, execute) => threads.run(target.threadId, withManualDevice(target, execute)),
-		withAgentCommand: (target, execute) => threads.run(target.threadId, withAgentDevice(target, (ready, session) => execute(ready.agentDevice, session))),
+		withAgentCommand: (target, execute) => threads.run(target.threadId, withAgentDevice(target, (ready, session) => ready.agentDevice ? execute(ready.agentDevice, session) : Effect.fail(new DeviceHostUnavailableError({
+			hostId: target.hostId,
+			reason: "This host uses semantic device control. Use cua.getDevice() and element refs."
+		})))),
 		open: (value) => threads.run(value.threadId, openWithAccess(value, "manual")),
 		agentOpen: (value) => threads.run(value.threadId, openWithAccess(value, "agent")),
 		close: (value) => closeWithAccess(value, "manual"),
@@ -47498,17 +48341,17 @@ const makeWithHosts = Effect.fn("DeviceService.makeWithHosts")(function* (input)
 		}))
 	};
 });
-const make$80 = Effect.gen(function* () {
+const make$79 = Effect.gen(function* () {
 	const discover = yield* make$87();
 	const actions = yield* make$86();
 	return yield* makeWithHosts({
-		local: make$82(),
-		ssh: make$81,
+		local: make$81(),
+		ssh: make$80,
 		discover,
 		actions
 	});
 }).pipe(Effect.provide(layer$73));
-const layer$71 = Layer.effect(DeviceService, make$80);
+const layer$70 = Layer.effect(DeviceService, make$79);
 //#endregion
 //#region src/serverRuntimeStartup.ts
 var ServerRuntimeStartupError = class extends Schema$1.TaggedErrorClass()("ServerRuntimeStartupError", {
@@ -47653,7 +48496,7 @@ const startProviderRecovery = Effect.fn("startup.startProviderRecovery")(functio
 	yield* input.recover;
 	yield* input.startReaper;
 });
-const make$79 = Effect.gen(function* () {
+const make$78 = Effect.gen(function* () {
 	const serverConfig = yield* ServerConfig$1;
 	const keybindings = yield* Keybindings;
 	const orchestrationReactor = yield* OrchestrationReactor;
@@ -47800,7 +48643,7 @@ const make$79 = Effect.gen(function* () {
 		enqueueCommand: commandGate.enqueueCommand
 	};
 });
-const layer$70 = Layer.effect(ServerRuntimeStartup, make$79);
+const layer$69 = Layer.effect(ServerRuntimeStartup, make$78);
 //#endregion
 //#region src/serverRuntimeState.ts
 const PersistedServerRuntimeState = Schema$1.Struct({
@@ -47957,7 +48800,7 @@ function expandHomePath$2(input, path) {
 	if (input.startsWith("~/") || input.startsWith("~\\")) return path.join(NodeOS.homedir(), input.slice(2));
 	return input;
 }
-const make$78 = Effect.gen(function* () {
+const make$77 = Effect.gen(function* () {
 	const fileSystem = yield* FileSystem.FileSystem;
 	const path = yield* Path$1.Path;
 	const statWorkspaceRoot = Effect.fn("WorkspacePaths.statWorkspaceRoot")(function* (workspaceRoot, normalizedWorkspaceRoot, phase) {
@@ -48014,7 +48857,7 @@ const make$78 = Effect.gen(function* () {
 		resolveRelativePathWithinRoot
 	});
 });
-const layer$69 = Layer.effect(WorkspacePaths, make$78);
+const layer$68 = Layer.effect(WorkspacePaths, make$77);
 //#endregion
 //#region src/cli/project.ts
 const isEnvironmentHttpCommonError = Schema$1.is(EnvironmentHttpCommonError);
@@ -48120,7 +48963,7 @@ const projectCommandUuid = Crypto.Crypto.pipe(Effect.flatMap((crypto) => crypto.
 	operation: "generateProjectCommandId",
 	cause
 })));
-const ProjectCliRuntimeLive = Layer.mergeAll(layer$69, OrchestrationLayerLive.pipe(Layer.provideMerge(layer$81), Layer.provideMerge(layerConfig)));
+const ProjectCliRuntimeLive = Layer.mergeAll(layer$68, OrchestrationLayerLive.pipe(Layer.provideMerge(layer$81), Layer.provideMerge(layerConfig)));
 const PROJECT_CLI_LIVE_SERVER_TIMEOUT = Duration.seconds(1);
 const withProjectCliSessionToken = (environmentAuth, run) => Effect.acquireUseRelease(environmentAuth.issueSession({
 	scopes: AuthAdministrativeScopes,
@@ -48222,7 +49065,7 @@ const runProjectMutation = Effect.fn("runProjectMutation")(function* (flags, run
 			});
 			yield* Console.log(output);
 		}).pipe(Effect.provide(offlineRuntimeLayer));
-	}).pipe(Effect.provide(Layer.mergeAll(runtimeLayer, layer$69).pipe(Layer.provideMerge(FetchHttpClient.layer), Layer.provide(layer$118(config)), Layer.provide(Layer.succeed(References.MinimumLogLevel, minimumLogLevel)))));
+	}).pipe(Effect.provide(Layer.mergeAll(runtimeLayer, layer$68).pipe(Layer.provideMerge(FetchHttpClient.layer), Layer.provide(layer$118(config)), Layer.provide(Layer.succeed(References.MinimumLogLevel, minimumLogLevel)))));
 });
 const projectAddCommand = Command.make("add", {
 	...projectLocationFlags,
@@ -51938,7 +52781,7 @@ const makeTerminationError$1 = (handle) => Effect.match(handle.exitCode, {
 //#region ../../packages/effect-acp/src/client.ts
 const MAX_STDERR_CALLBACK_CHARS = 32768;
 var AcpClient = class extends Context.Service()("effect-acp/client/AcpClient") {};
-const make$77 = Effect.fn("effect-acp/AcpClient.make")(function* (stdio, options = {}, terminationError) {
+const make$76 = Effect.fn("effect-acp/AcpClient.make")(function* (stdio, options = {}, terminationError) {
 	const coreHandlers = {};
 	const notificationHandlers = {
 		sessionUpdate: {
@@ -52105,7 +52948,7 @@ const layerChildProcess$1 = (handle, options = {}) => {
 		})), Stream.drain)) : stdout
 	};
 	const terminationError = makeTerminationError$1(handle);
-	return Layer.effect(AcpClient, make$77(stdio, options, terminationError));
+	return Layer.effect(AcpClient, make$76(stdio, options, terminationError));
 };
 //#endregion
 //#region src/provider/Drivers/AntigravitySkills.ts
@@ -53384,7 +54227,7 @@ const Reply = Schema$1.Struct({
 	id: Schema$1.String,
 	result: Schema$1.Struct({ ok: Schema$1.Boolean })
 });
-const make$76 = Effect.fn("DeviceCommandProxy.make")(function* () {
+const make$75 = Effect.fn("DeviceCommandProxy.make")(function* () {
 	const http = yield* HttpClient.HttpClient;
 	const daemonSessions = /* @__PURE__ */ new WeakMap();
 	return Effect.fn("DeviceCommandProxy.execute")(function* (endpoint, session, payload) {
@@ -53437,81 +54280,7 @@ const make$76 = Effect.fn("DeviceCommandProxy.make")(function* () {
 	})));
 });
 var DeviceCommandProxy = class extends Context.Service()("@p4code/cli/device/DeviceCommandProxy") {};
-const layer$68 = Layer.effect(DeviceCommandProxy, make$76().pipe(Effect.map((execute) => ({ execute }))));
-//#endregion
-//#region src/device/DeviceScreenshot.ts
-const MAX_SCREENSHOT_BYTES = 8 * 1024 * 1024;
-var DeviceScreenshotFailure = class extends Data.TaggedError("DeviceScreenshotFailure") {};
-const MAX_DIMENSION = 16384;
-const MAX_PIXELS = 64 * 1024 * 1024;
-const SCREENSHOT_TIMEOUT_MS = 2e4;
-const PNG_HEADER_BYTES = 33;
-const PNG_CHUNK_OVERHEAD = 12;
-const PNG_SIGNATURE = Buffer.from([
-	137,
-	80,
-	78,
-	71,
-	13,
-	10,
-	26,
-	10
-]);
-function pngDimensions(png) {
-	const buffer = Buffer.from(png.buffer, png.byteOffset, png.byteLength);
-	if (buffer.length < PNG_HEADER_BYTES || buffer.length > 8388608 || !buffer.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE) || buffer.readUInt32BE(8) !== 13 || buffer.toString("ascii", 12, 16) !== "IHDR") throw new DeviceScreenshotFailure({ message: "Invalid PNG screenshot." });
-	const width = buffer.readUInt32BE(16);
-	const height = buffer.readUInt32BE(20);
-	if (!width || !height || width > MAX_DIMENSION || height > MAX_DIMENSION || width * height > MAX_PIXELS) throw new DeviceScreenshotFailure({ message: "Screenshot dimensions exceed limits." });
-	let offset = PNG_HEADER_BYTES;
-	let imageData = false;
-	let ended = false;
-	while (offset + PNG_CHUNK_OVERHEAD <= buffer.length) {
-		const length = buffer.readUInt32BE(offset);
-		const type = buffer.toString("ascii", offset + 4, offset + 8);
-		const next = offset + PNG_CHUNK_OVERHEAD + length;
-		if (next > buffer.length || type === "IHDR") throw new DeviceScreenshotFailure({ message: "Invalid PNG chunk." });
-		if (type === "IDAT") imageData = true;
-		if (type === "IEND") {
-			ended = length === 0 && next === buffer.length;
-			break;
-		}
-		offset = next;
-	}
-	if (!imageData || !ended) throw new DeviceScreenshotFailure({ message: "Incomplete PNG screenshot." });
-	return {
-		width,
-		height
-	};
-}
-const make$75 = Effect.fn("DeviceScreenshot.make")(function* () {
-	const http = yield* HttpClient.HttpClient;
-	return Effect.fn("DeviceScreenshot.capture")(function* (ready, session) {
-		const origin = yield* Effect.try(() => new URL(ready.hub.origin));
-		if (origin.protocol !== "http:" || origin.hostname !== "127.0.0.1" || !origin.port || origin.username || origin.password || origin.pathname !== "/" || origin.search || origin.hash) return yield* new DeviceScreenshotFailure({ message: "Invalid owned hub." });
-		const vendor = session.platform === "ios" ? "serve-sim" : "serve-emu";
-		const response = yield* http.execute(HttpClientRequest.post(`${origin.origin}/vendor/${vendor}/api/screenshot?device=${encodeURIComponent(session.deviceId)}`));
-		if (response.status !== 200) return yield* new DeviceScreenshotFailure({ message: "Screenshot rejected." });
-		let bytes = 0;
-		const chunks = [];
-		yield* response.stream.pipe(Stream.runForEach((chunk) => Effect.gen(function* () {
-			bytes += chunk.byteLength;
-			if (bytes > 8388608) return yield* new DeviceScreenshotFailure({ message: "Screenshot too large." });
-			chunks.push(chunk);
-		})));
-		const png = Buffer.concat(chunks, bytes);
-		return {
-			png,
-			...yield* Effect.try(() => pngDimensions(png))
-		};
-	}, Effect.scoped, Effect.timeout(Duration.millis(SCREENSHOT_TIMEOUT_MS)), Effect.mapError(() => new DeviceOperationError({
-		operation: "screenshot",
-		reason: "request_failed",
-		cause: "Device screenshot could not be captured."
-	})));
-});
-var DeviceScreenshot = class extends Context.Service()("@p4code/cli/device/DeviceScreenshot") {};
-const layer$67 = Layer.effect(DeviceScreenshot, make$75().pipe(Effect.map((capture) => ({ capture }))));
+const layer$67 = Layer.effect(DeviceCommandProxy, make$75().pipe(Effect.map((execute) => ({ execute }))));
 //#endregion
 //#region src/device/DeviceHubRoute.ts
 const DEVICE_HUB_PROXY_PREFIX = "/api/device-hub";
@@ -53715,12 +54484,12 @@ const requireThreadSpawn = Effect.fn("mcp.requireThreadSpawn")(function* (fusion
 const isDeviceToolUnavailableError = Schema$1.is(DeviceToolUnavailableError);
 const isDeviceActionUnavailableError = Schema$1.is(DeviceActionUnavailableError);
 /** Internal bridge; tool payloads never choose thread identity or daemon credentials. */
-const withDeviceInvocation = (execute) => Effect.gen(function* () {
+const withDeviceInvocation = (execute, capability = "devices") => Effect.gen(function* () {
 	const invocation = yield* McpInvocationContext;
 	const service = yield* DeviceService;
 	const lifetime = invocation.authorizationLifetime;
 	const denied = () => new DeviceToolUnavailableError({ reason: "Device command unavailable or authorization changed." });
-	if (!invocation.capabilities.has("devices") || !lifetime?.revocation || lifetime.revoked) return yield* denied();
+	if (!invocation.capabilities.has(capability) || !lifetime?.revocation || lifetime.revoked) return yield* denied();
 	const work = execute(service, invocation.threadId).pipe(Effect.tap(() => lifetime.revoked ? Effect.fail(denied()) : Effect.void), Effect.mapError((error) => isDeviceToolUnavailableError(error) || isDeviceActionUnavailableError(error) ? error : denied()));
 	return yield* Effect.raceFirst(work, Deferred.await(lifetime.revocation).pipe(Effect.andThen(Effect.fail(denied()))));
 });
@@ -53735,6 +54504,7 @@ const MAX_AX_BYTES = 512 * 1024;
 const AX_TIMEOUT_MS = 1e4;
 const MAX_AX_EXTENT = 32768;
 const MIN_AX_EXTENT = 2;
+const isToolUnavailable = Schema$1.is(DeviceToolUnavailableError);
 const AxFrames = Schema$1.Array(Schema$1.Struct({ frame: Schema$1.Struct({
 	x: Schema$1.Number,
 	y: Schema$1.Number,
@@ -53774,6 +54544,7 @@ const makeComputerUseDevices = Effect.fn("ComputerUseDevices.make")(function* ()
 			const state = yield* service.agentList;
 			const device = state.devices.find((device) => device.hostId === input.hostId && device.id === input.deviceId && device.platform === input.platform);
 			if (!device) return yield* stale();
+			if (device.physical) return yield* new DeviceToolUnavailableError({ reason: "Physical-device UI control is not supported by this adapter. Pairing, trust, Developer Mode and signing must be configured separately; use supported device-management workflows." });
 			const session = yield* service.agentOpen({
 				threadId,
 				hostId: input.hostId,
@@ -53811,8 +54582,16 @@ const makeComputerUseDevices = Effect.fn("ComputerUseDevices.make")(function* ()
 			deviceId: target.deviceId
 		}, (ready, session) => Effect.gen(function* () {
 			if (session.leaseId !== input.leaseId) return yield* stale();
+			if (input.method === "recording") {
+				if (!ready.xcode || session.platform !== "ios") return yield* new DeviceToolUnavailableError({ reason: "Recording is unavailable on this device adapter." });
+				return yield* ready.xcode.recording(session, input.action).pipe(Effect.mapError((error) => new DeviceToolUnavailableError({ reason: String(error.cause) })));
+			}
+			if (input.method === "semantic") {
+				if (!ready.xcode || session.platform !== "ios") return yield* new DeviceToolUnavailableError({ reason: "Semantic device actions require a supported local Xcode adapter. Use the capabilities returned by getAXState()." });
+				return yield* ready.xcode.action(session, input.action).pipe(Effect.mapError((error) => new DeviceToolUnavailableError({ reason: String(error.cause) })));
+			}
 			if (input.method === "screenshot") {
-				const capture = yield* screenshots.capture(ready, session);
+				const capture = yield* ready.xcode && session.platform === "ios" ? ready.xcode.screenshot(session).pipe(Effect.mapError((error) => new DeviceToolUnavailableError({ reason: String(error.cause) }))) : screenshots.capture(ready, session);
 				return {
 					mimeType: "image/png",
 					data: capture.png.toString("base64"),
@@ -53820,6 +54599,7 @@ const makeComputerUseDevices = Effect.fn("ComputerUseDevices.make")(function* ()
 					height: capture.height
 				};
 			}
+			if (ready.xcode && session.platform === "ios") return yield* ready.xcode.state(session, input.sinceScreenHash).pipe(Effect.mapError((error) => new DeviceToolUnavailableError({ reason: String(error.cause) })));
 			if (session.platform !== "ios") return yield* new DeviceToolUnavailableError({ reason: "CUA accessibility state is currently supported only for iOS Simulator. Use a screenshot for this device." });
 			const route = resolveDeviceHubRoute({
 				target: {
@@ -53847,12 +54627,13 @@ const makeComputerUseDevices = Effect.fn("ComputerUseDevices.make")(function* ()
 				leaseId: session.leaseId,
 				accessibility
 			};
-		}).pipe(Effect.scoped, Effect.timeout(AX_TIMEOUT_MS), Effect.mapError((error) => new DeviceOperationError({
-			operation: "command",
-			reason: "request_failed",
-			cause: error.message
-		}))));
-	})).pipe(Effect.provideService(McpInvocationContext, scope), Effect.provideService(DeviceService, devices), Effect.mapError((error) => new ComputerUseError({
+		}).pipe(Effect.scoped, Effect.timeoutOrElse({
+			duration: AX_TIMEOUT_MS,
+			orElse: () => Effect.gen(function* () {
+				return yield* new DeviceToolUnavailableError({ reason: ready.xcode && "diagnose" in ready.xcode ? yield* ready.xcode.diagnose : "Device state request timed out. Check device support before selecting the device again." });
+			})
+		}), Effect.mapError((error) => isToolUnavailable(error) ? error : new DeviceToolUnavailableError({ reason: error instanceof Error ? error.message : String(error) }))));
+	}), "computer-use").pipe(Effect.provideService(McpInvocationContext, scope), Effect.provideService(DeviceService, devices), Effect.mapError((error) => new ComputerUseError({
 		reason: "unavailable",
 		detail: error.message
 	})));
@@ -65806,6 +66587,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			context.inFlightTools.delete(index);
 		}
 		context.inFlightTools.clear();
+		for (const toolUseId of context.subagentModels.keys()) if (!context.subagentTasks.has(toolUseId)) context.subagentModels.delete(toolUseId);
 		for (const block of turnState.assistantTextBlockOrder) yield* completeAssistantTextBlock(context, block, {
 			force: true,
 			rawMethod: "claude/result",
@@ -65974,9 +66756,31 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			discard: true
 		});
 	});
+	const recordSubagentModel = Effect.fn("recordSubagentModel")(function* (context, toolUseId, model) {
+		if (!toolUseId || !model || context.subagentModels.get(toolUseId) === model) return;
+		const task = context.subagentTasks.get(toolUseId);
+		if (!task && !Array.from(context.inFlightTools.values()).some((tool) => tool.itemId === toolUseId)) return;
+		context.subagentModels.set(toolUseId, model);
+		if (!task) return;
+		yield* offerRuntimeEvent({
+			...yield* makeEventStamp(),
+			type: "task.progress",
+			provider: PROVIDER$6,
+			threadId: context.session.threadId,
+			...context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {},
+			payload: {
+				taskId: RuntimeTaskId.make(task.taskId),
+				description: task.description,
+				toolUseId,
+				...task.subagentType ? { subagentType: task.subagentType } : {},
+				model
+			}
+		});
+	});
 	const handleStreamEvent = Effect.fn("handleStreamEvent")(function* (context, message) {
 		if (message.type !== "stream_event") return;
 		const { event } = message;
+		if (event.type === "message_start") yield* recordSubagentModel(context, message.parent_tool_use_id, event.message.model);
 		if (event.type === "message_delta") {
 			if (message.parent_tool_use_id !== null && message.parent_tool_use_id !== void 0) return;
 			const snapshot = normalizeClaudeActiveTokenUsage(event.usage, context.lastKnownContextWindow, context.lastKnownTotalProcessedTokens);
@@ -66297,10 +67101,12 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 				rawPayload: message
 			});
 			context.inFlightTools.delete(index);
+			if (!context.subagentTasks.has(tool.itemId)) context.subagentModels.delete(tool.itemId);
 		}
 	});
 	const handleAssistantMessage = Effect.fn("handleAssistantMessage")(function* (context, message) {
 		if (message.type !== "assistant") return;
+		yield* recordSubagentModel(context, message.parent_tool_use_id, message.message.model);
 		if (!context.turnState) {
 			const turnId = TurnId.make(yield* randomUUIDv4);
 			const startedAt = yield* nowIso;
@@ -66407,6 +67213,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		}
 		switch (message.subtype) {
 			case "init":
+				context.currentApiModelId = message.model || context.currentApiModelId;
 				yield* offerRuntimeEvent({
 					...base,
 					type: "session.configured",
@@ -66477,7 +67284,12 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 				return;
 			case "task_started": {
 				const requestedModel = readString((message.tool_use_id ? Array.from(context.inFlightTools.values()).find((tool) => tool.itemId === message.tool_use_id) : void 0)?.input.model);
-				const model = requestedModel === "inherit" ? context.currentApiModelId : requestedModel;
+				const model = (message.tool_use_id ? context.subagentModels.get(message.tool_use_id) : void 0) ?? (requestedModel === "inherit" ? context.currentApiModelId : requestedModel);
+				if (message.tool_use_id) context.subagentTasks.set(message.tool_use_id, {
+					taskId: message.task_id,
+					description: message.description,
+					...message.subagent_type ? { subagentType: message.subagent_type } : {}
+				});
 				yield* offerRuntimeEvent({
 					...base,
 					type: "task.started",
@@ -66528,6 +67340,11 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 						...message.tool_use_id ? { toolUseId: message.tool_use_id } : {}
 					}
 				});
+				for (const [toolUseId, task] of context.subagentTasks) if (toolUseId === message.tool_use_id || task.taskId === message.task_id) {
+					context.subagentTasks.delete(toolUseId);
+					context.subagentModels.delete(toolUseId);
+				}
+				if (message.tool_use_id) context.subagentModels.delete(message.tool_use_id);
 				return;
 			case "files_persisted":
 				yield* offerRuntimeEvent({
@@ -67228,6 +68045,8 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			turns: [],
 			inFlightTools,
 			claudeTasks,
+			subagentTasks: /* @__PURE__ */ new Map(),
+			subagentModels: /* @__PURE__ */ new Map(),
 			turnState: void 0,
 			pendingTurnRequest: void 0,
 			steeredMessages: /* @__PURE__ */ new Map(),
@@ -125492,6 +126311,7 @@ const RPC_REQUIRED_SCOPE = /* @__PURE__ */ new Map([
 	[WS_METHODS.serverUpdateServer, AuthOrchestrationOperateScope],
 	[WS_METHODS.serverUpsertKeybinding, AuthOrchestrationOperateScope],
 	[WS_METHODS.serverRemoveKeybinding, AuthOrchestrationOperateScope],
+	[WS_METHODS.threadHandoff, AuthOrchestrationReadScope],
 	[WS_METHODS.btwAsk, AuthOrchestrationReadScope],
 	[WS_METHODS.btwCancel, AuthOrchestrationReadScope],
 	[WS_METHODS.tasksList, AuthOrchestrationReadScope],
@@ -126344,6 +127164,27 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker, computerUseBrok
 			operation: "getUsageReport",
 			detail: "This provider does not report account usage."
 		})), { "rpc.aggregate": "server" }),
+		[WS_METHODS.threadHandoff]: (input) => observeRpcEffect$1(WS_METHODS.threadHandoff, Effect.gen(function* () {
+			const fail = (detail) => new TextGenerationError({
+				operation: "createHandoff",
+				detail
+			});
+			if (!projectionSnapshotQuery.getHandoffContext || !textGeneration.generateBtwAnswer) return yield* fail("Handoff generation is unavailable on this server.");
+			const context = yield* projectionSnapshotQuery.getHandoffContext(input.threadId).pipe(Effect.mapError(() => fail("Could not read thread history.")));
+			if (Option.isNone(context)) return yield* fail("Thread or project is no longer available.");
+			const settings = yield* serverSettings.getSettings.pipe(Effect.mapError(() => fail("Could not read text generation settings.")));
+			const result = yield* textGeneration.generateBtwAnswer({
+				cwd: context.value.projectId === P4_CHAT_PROJECT_ID ? config.chatWorkspaceDir : context.value.cwd,
+				modelSelection: settings.textGenerationModelSelection,
+				context: context.value.transcript,
+				question: "Write a self-contained handoff for a new coding-agent thread continuing this work. Include objective, latest user constraints, decisions, completed changes, verification evidence and its limits, pending work, important paths and identifiers. Reconcile builder and watcher histories without duplicating their shared facts. Later user corrections win. Preserve explicit authorization limits; do not invent approvals or claim missing work is complete. Histories may be bounded: say when earlier context is unavailable. Return only the handoff in concise Markdown, addressed to the next agent."
+			});
+			if (!result.answer.trim()) return yield* fail("Model returned an empty handoff. Try again.");
+			return {
+				projectId: context.value.projectId,
+				text: result.answer.trim()
+			};
+		}), { "rpc.aggregate": "thread" }),
 		[WS_METHODS.btwAsk]: (input) => observeRpcEffect$1(WS_METHODS.btwAsk, btw ? btw.ask(input) : Effect.fail(new BtwAskError({ detail: "Contextual questions are unavailable on this server." })), { "rpc.aggregate": "server" }),
 		[WS_METHODS.btwCancel]: (input) => observeRpcEffect$1(WS_METHODS.btwCancel, btw ? btw.cancel(input) : Effect.succeed({}), { "rpc.aggregate": "server" }),
 		[WS_METHODS.serverGetUsageSummary]: (input) => observeRpcEffect$1(WS_METHODS.serverGetUsageSummary, usage.readSummary(input), { "rpc.aggregate": "server" }),
@@ -127104,6 +127945,13 @@ const makeProviderAdapterRegistry = Effect.fn("makeProviderAdapterRegistry")(fun
 });
 const ProviderAdapterRegistryLive = Layer.effect(ProviderAdapterRegistry, makeProviderAdapterRegistry());
 //#endregion
+//#region src/provider/ComputerUsePrompts.ts
+/** Routing guidance is injected only when the session has P4's Computer Use endpoint. */
+const COMPUTER_USE_ROUTING_PROMPT = "P4 Computer Use is enabled for this session through the cua_repl MCP server. For natural-language requests to inspect or interact with a native desktop app, use its js tool by default, even when the user does not mention P4 or Computer Use. Do not substitute provider-builtin Computer Use, AppleScript, shell automation, or another integration unless the user explicitly requests that path. For a named app, start directly with const app = await cua.getApp(exactNameOrBundleId); read the automatically returned state/image and stop if it answers the request. Reuse the handle and batch safe actions; do not repeat selection or unchanged state. For Device Hub, simulator, emulator, or connected-device requests, use cua.listDevices() once, then cua.getDevice({hostId,deviceId,platform}) with exact discovered IDs. Selection already emits initial device state. Reuse its handle; do not print the handle or repeat that state before acting. Never substitute macOS getApp('Simulator'). Device hosts are scoped to this provider environment and can differ from the desktop host. If device discovery, opening, inspection, or interaction reports missing permission or unavailable control, stop and report the exact limitation. Do not retry through screenshots, shell simctl, Xcode tools, or another MCP server. Do not call getState/getApp, control the P4 desktop app, or open device settings to work around a device API failure. Missing consent, unavailable devices, or unsupported operations are limitations to report, not permission to switch hosts or bypass the tool.";
+function withComputerUseRouting(input, enabled) {
+	return enabled ? `<p4-computer-use>\n${COMPUTER_USE_ROUTING_PROMPT}\n</p4-computer-use>\n\n${input ?? ""}` : input;
+}
+//#endregion
 //#region src/mcp/McpSessionRegistry.ts
 var McpSessionRegistry = class extends Context.Service()("@p4code/cli/mcp/McpSessionRegistry") {};
 /**
@@ -127877,7 +128725,10 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (options)
 				...input.modelSelection?.model ? { "provider.model": input.modelSelection.model } : {}
 			});
 			yield* touchActiveMcpThread(input.threadId);
-			const turn = yield* routed.adapter.sendTurn(input);
+			const turn = yield* routed.adapter.sendTurn({
+				...input,
+				input: withComputerUseRouting(input.input, !forCompaction && Boolean(readMcpProviderSession(input.threadId)?.computerUse))
+			});
 			yield* directory.upsert({
 				threadId: input.threadId,
 				provider: routed.adapter.provider,
@@ -128362,7 +129213,7 @@ const mcpToolkit = (toolkit) => Layer.effectDiscard(Effect.gen(function* () {
 //#endregion
 //#region src/mcp/toolkits/computerUse/tools.ts
 const ComputerUseJsTool = Tool.make("js", {
-	description: "Run JavaScript in a persistent P4 Computer Use REPL. Start with await cua.getState(). Use cua.createBrowserTab('iab', url, {visible:true}) or cua.getTab(tabId) for P4 browser tabs. Tab methods: getState(), goto(url), click({locator}), type({text,locator?,clear?}), press({key,modifiers?}), scroll({deltaY,deltaX?}). Print results with nodeRepl.write(value); emit PNG/JPEG with nodeRepl.emitImage({mimeType,data}) using base64 data. Top-level await and persistent let bindings are supported. Await each operation. Reset after timeout or host disconnect. For available native apps, use cua.getApp(exactNameOrBundleId), then getAXState(), click(elementIndex), or setValue(elementIndex,text) to replace a field value in the background. Selection and getAXState print numbered accessibility state; Several deterministic actions against distinct unchanged elements may share one snapshot. Each used handle expires; the host revalidates remaining native handles and rejects changed elements. Read fresh state after the action batch before deciding the next action. getScreenshot() emits the selected app window; getAXStateAndScreenshot() emits both. Legacy getState(), click({elementId}), type({elementId,text}), windows(), and screenshot(windowId) remain supported. Native control preserves foreground focus and the system pointer. Coordinate, key, drag, scroll, and activation input are unsupported; do not use global input or activate the app as a fallback. P4Code shows the controlled native window and a persistent independent white pointer with a blue glow in its embedded live view. Hide closes only the view; use Show live view in the Computer Use control to reopen it. Stop ends thread control; reset clears the view and handles. Google Chrome can be controlled as a native app using cua.getApp('Google Chrome'); Chrome extension/CDP tab APIs are not exposed by this host. Native app availability and macOS permission states are reported by the host; never assume native apps are supported. The host may be a different machine from the provider server. Device hub simulators are scoped to the provider environment: await cua.listDevices(), then await cua.getDevice({hostId,deviceId,platform}) using exact discovered IDs. The device handle supports getAXState() (raw iOS accessibility state), getScreenshot(), getAXStateAndScreenshot(), click([x,y]) in device coordinates from fresh AX state, typeText(text), and close(). No device key, scroll, or drag APIs are currently exposed. Device consent must already be enabled in P4 Settings. Use timeout_ms:60000 for initial device startup. Reset invalidates device handles; device viewer sessions remain under Devices until explicitly closed. Never substitute macOS Simulator.app AX for simulated-app state.",
+	description: "P4 Code Computer Use: control native apps through P4Code's signed helper. Run JavaScript in a persistent REPL. On the first call, execute exactly one entry-point operation and read its automatic output before continuing. When the user names an app, execute only const app = await cua.getApp(exactNameBundleIdOrPath); this already prints its state and includes a screenshot when AX exposes no app content. Use await cua.getState() only when discovery is needed. Use cua.createBrowserTab('iab', url, {visible:true}) or cua.getTab(tabId) for P4 browser tabs. Tab methods: getState(), goto(url), click({locator}), type({text,locator?,clear?}), press({key,modifiers?}), scroll({deltaY,deltaX?}). Print results with nodeRepl.write(value); emit PNG/JPEG with nodeRepl.emitImage({mimeType,data}) using base64 data. Top-level await and persistent let bindings are supported. Await each operation. Bindings disappear after helper restart, host disconnect, reset, or tray Stop. When resuming a task, guard a remembered binding within the same js call: if (typeof app === 'undefined') { globalThis.app = await cua.getApp('Spotify'); } else { await app.getScreenshot(); }. Substitute the named app and intended operation. The missing-binding branch selects only and prints fresh state; decide the next action after reading it. Never spend a separate tool call checking whether a binding exists. Reset after timeout or host disconnect. For available native apps, use cua.getApp(exactNameBundleIdOrPath), then getAXState(), click(elementIndex), or setValue(elementIndex,text) to replace a field value in the background. Selection already prints numbered accessibility state; reuse the app handle without selecting or reading it again before the first action. Snapshot text is bounded; use getAXState({filter:'Pause'}) for case-insensitive text filtering across the snapshot, including controls omitted from the initial output. Use {emit:false} on getApp(name, options), getAXState(options), or getScreenshot(options) when processing the returned value yourself; do not print auto-emitted output again. Several deterministic actions against distinct unchanged elements may share one snapshot. Each used element index expires after one action. To click the same control again, refresh with getAXState({filter: controlLabel}) first, even inside a batch; never reuse its old index. The host revalidates remaining native handles and rejects changed elements. Read fresh state after the action batch before deciding the next action. If selection includes a screenshot because AX exposes only window controls or menus, read that image immediately and finish if it answers the request. If no image is included, use getScreenshot() to read visual content; do not repeat unchanged snapshots hoping for missing accessibility content. getScreenshot() emits the selected app window; getAXStateAndScreenshot() emits both. Legacy getState(), click({elementId}), type({elementId,text}), windows(), and screenshot(windowId) remain supported. Native control preserves foreground focus and the system pointer. Coordinate, key, drag, scroll, and activation input are unsupported; do not use global input or activate the app as a fallback. P4Code shows the controlled native window and a persistent independent black pointer with a thin contrast edge in its embedded live view. Hide closes only the view; use Show live view in the Computer Use control to reopen it. Stop ends thread control; reset clears the view and handles. Google Chrome can be controlled as a native app using cua.getApp('Google Chrome'); Chrome extension/CDP tab APIs are not exposed by this host. Native app availability and macOS permission states are reported by the host; never assume native apps are supported. The host may be a different machine from the provider server. Device hub simulators are scoped to the provider environment: await cua.listDevices(), then await cua.getDevice({hostId,deviceId,platform}) using exact discovered IDs. Selection automatically emits initial AX state (or a screenshot on other platforms); reuse the handle without repeating that capture or printing the handle. A permission or unavailable-control error requires stopping and reporting it, never shell or alternative-tool fallback. The device handle supports getAXState() (raw iOS accessibility state), getScreenshot(), getAXStateAndScreenshot(), click([x,y]) in device coordinates from fresh AX state, typeText(text), and close(). When getAXState() reports adapter apple-xcode or xcodebuildmcp, use semantic refs from capture.elements and only advertised capabilities: click(elementRef), typeText(text,{elementRef,replaceExisting:true}), swipe({withinElementRef,direction}), drag({elementRef,direction}), batch([{action:\"tap\",elementRef},...]), and recordVideo(\"start\"|\"stop\") only when advertised in capabilities. getAXState({sinceScreenHash}) avoids unchanged snapshots. Batch only same-screen taps; action output includes updated capture. On stale-ref errors inspect fresh state and choose a current ref; never replay an action automatically. Physical-device UI control and device key input are unavailable. Device consent must already be enabled in P4 Settings. Use timeout_ms:60000 for initial device startup. Reset invalidates device handles; device viewer sessions remain under Devices until explicitly closed. Never substitute macOS Simulator.app AX for simulated-app state.",
 	parameters: Schema$1.Struct({
 		...ComputerUseJsInput.fields,
 		hostId: Schema$1.optional(TrimmedNonEmptyString).annotate({ description: "Select an available host when more than one is connected. Reset before changing hosts." })
@@ -132626,6 +133477,7 @@ function runtimeEventToActivities(event, taskTitle, compressMode) {
 			summary: event.payload.description.trim().length > 0 ? truncateDetail(event.payload.description, 120) : "Reasoning update",
 			payload: {
 				taskId: event.payload.taskId,
+				...event.payload.model ? { model: event.payload.model } : {},
 				...event.provider === "claudeAgent" && event.payload.workflowScript?.instanceId === event.providerInstanceId ? { workflowScript: event.payload.workflowScript } : {},
 				...event.payload.description.trim().length > 0 ? { title: truncateDetail(event.payload.description, 120) } : {},
 				detail: event.payload.summary ?? event.payload.description,
@@ -137341,13 +138193,13 @@ const CheckpointingLayerLive = Layer.empty.pipe(Layer.provideMerge(layer$46), La
 const PortScannerLayerLive = layer$45.pipe(Layer.provide(layer$82));
 const TerminalLayerLive = layer$44.pipe(Layer.provide(PtyAdapterLive), Layer.provide(PortScannerLayerLive));
 const PreviewLayerLive = Layer.empty.pipe(Layer.provideMerge(layer$19), Layer.provideMerge(PortScannerLayerLive));
-const WorkspaceEntriesLayerLive = layer$17.pipe(Layer.provide(layer$69));
-const WorkspaceFileSystemLayerLive = layer$16.pipe(Layer.provide(layer$69), Layer.provide(WorkspaceEntriesLayerLive));
-const WorkspaceLayerLive = Layer.mergeAll(layer$69, WorkspaceEntriesLayerLive, WorkspaceFileSystemLayerLive);
-const ProjectFaviconResolverLayerLive = layer$63.pipe(Layer.provide(layer$69), Layer.provide(layer$64));
+const WorkspaceEntriesLayerLive = layer$17.pipe(Layer.provide(layer$68));
+const WorkspaceFileSystemLayerLive = layer$16.pipe(Layer.provide(layer$68), Layer.provide(WorkspaceEntriesLayerLive));
+const WorkspaceLayerLive = Layer.mergeAll(layer$68, WorkspaceEntriesLayerLive, WorkspaceFileSystemLayerLive);
+const ProjectFaviconResolverLayerLive = layer$63.pipe(Layer.provide(layer$68), Layer.provide(layer$64));
 const AuthLayerLive = layer$111.pipe(Layer.provideMerge(PersistenceLayerLive), Layer.provide(layer$115));
 const ProviderRuntimeLayerLive = ProviderSessionReaperLive.pipe(Layer.provideMerge(ProviderLayerLive), Layer.provideMerge(OrchestrationLayerLive));
-const RuntimeCoreDependenciesLive = ReactorLayerLive.pipe(Layer.provideMerge(layer$25), Layer.provideMerge(Layer.mergeAll(PullRequestServiceLive, CheckpointingLayerLive, SourceControlProviderRegistryLayerLive)), Layer.provideMerge(GitLayerLive), Layer.provideMerge(VcsLayerLive), Layer.provideMerge(ProviderAuthServiceLive), Layer.provideMerge(ProviderRuntimeLayerLive), Layer.provideMerge(Layer.mergeAll(TerminalLayerLive, PreviewLayerLive, RoutedTaskRepositoryLive)), Layer.provideMerge(Layer.mergeAll(PersistenceLayerLive, layer$86)), Layer.provideMerge(layer$80), Layer.provideMerge(ProviderRegistryLive), Layer.provideMerge(layer$58), Layer.provideMerge(Layer.mergeAll(layer$57, layer$71.pipe(Layer.provide(layer$82)), layer$67, layer$68)), Layer.provideMerge(layer$52), Layer.provideMerge(layer$53), Layer.provideMerge(layer$54), Layer.provideMerge(layer$55), Layer.provideMerge(layer$56)).pipe(Layer.provideMerge(ProviderInstanceRegistryHydrationLive), Layer.provideMerge(AntigravityInstallation.layer), Layer.provideMerge(ProviderEventLoggersLive), Layer.provideMerge(OpenCodeRuntimeLive), Layer.provideMerge(layer$60), Layer.provideMerge(layer$90.pipe(Layer.provide(layer$115))), Layer.provideMerge(WorkspaceLayerLive), Layer.provideMerge(ProjectFaviconResolverLayerLive), Layer.provideMerge(layer$81), Layer.provideMerge(layer$66), Layer.provideMerge(remoteComputerUseBindingsLayer.pipe(Layer.provide(layer$86))), Layer.provideMerge(layer$74), Layer.provideMerge(AuthLayerLive), Layer.provideMerge(layer$5.pipe(Layer.provideMerge(LinearClientLive), Layer.provideMerge(Layer.mergeAll(LinearMcpClientLive, TrackerSecretsLive)), Layer.provideMerge(Layer.mergeAll(layer$87, layer$21).pipe(Layer.provideMerge(layer$88), Layer.provideMerge(layer$89))))), Layer.provideMerge(layer$115));
+const RuntimeCoreDependenciesLive = ReactorLayerLive.pipe(Layer.provideMerge(layer$25), Layer.provideMerge(Layer.mergeAll(PullRequestServiceLive, CheckpointingLayerLive, SourceControlProviderRegistryLayerLive)), Layer.provideMerge(GitLayerLive), Layer.provideMerge(VcsLayerLive), Layer.provideMerge(ProviderAuthServiceLive), Layer.provideMerge(ProviderRuntimeLayerLive), Layer.provideMerge(Layer.mergeAll(TerminalLayerLive, PreviewLayerLive, RoutedTaskRepositoryLive)), Layer.provideMerge(Layer.mergeAll(PersistenceLayerLive, layer$86)), Layer.provideMerge(layer$80), Layer.provideMerge(ProviderRegistryLive), Layer.provideMerge(layer$58), Layer.provideMerge(Layer.mergeAll(layer$57, layer$70.pipe(Layer.provide(layer$82)), layer$72, layer$67)), Layer.provideMerge(layer$52), Layer.provideMerge(layer$53), Layer.provideMerge(layer$54), Layer.provideMerge(layer$55), Layer.provideMerge(layer$56)).pipe(Layer.provideMerge(ProviderInstanceRegistryHydrationLive), Layer.provideMerge(AntigravityInstallation.layer), Layer.provideMerge(ProviderEventLoggersLive), Layer.provideMerge(OpenCodeRuntimeLive), Layer.provideMerge(layer$60), Layer.provideMerge(layer$90.pipe(Layer.provide(layer$115))), Layer.provideMerge(WorkspaceLayerLive), Layer.provideMerge(ProjectFaviconResolverLayerLive), Layer.provideMerge(layer$81), Layer.provideMerge(layer$66), Layer.provideMerge(remoteComputerUseBindingsLayer.pipe(Layer.provide(layer$86))), Layer.provideMerge(layer$74), Layer.provideMerge(AuthLayerLive), Layer.provideMerge(layer$5.pipe(Layer.provideMerge(LinearClientLive), Layer.provideMerge(Layer.mergeAll(LinearMcpClientLive, TrackerSecretsLive)), Layer.provideMerge(Layer.mergeAll(layer$87, layer$21).pipe(Layer.provideMerge(layer$88), Layer.provideMerge(layer$89))))), Layer.provideMerge(layer$115));
 const UsageLayerLive = layer$23.pipe(Layer.provide(layer$90.pipe(Layer.provide(layer$115))));
 const RuntimeDependenciesLive = layer$22.pipe(Layer.provideMerge(RuntimeCoreDependenciesLive)).pipe(Layer.provideMerge(UsageLayerLive), Layer.provideMerge(layer$12), Layer.provideMerge(layer$11), Layer.provideMerge(layer$10), Layer.provideMerge(layer$77), Layer.provideMerge(layer$79), Layer.provideMerge(layer$78), Layer.provide(layer$119));
 /**
@@ -137358,7 +138210,7 @@ const RuntimeDependenciesLive = layer$22.pipe(Layer.provideMerge(RuntimeCoreDepe
 * this costs a server with no hub nothing but a layer.
 */
 const AssetSyncLive = layer$84.pipe(Layer.provideMerge(layer$85), Layer.provideMerge(layer$86));
-const RuntimeServicesLive = layer$70.pipe(Layer.provideMerge(layer$1), Layer.provideMerge(AssetSyncLive), Layer.provideMerge(RuntimeDependenciesLive));
+const RuntimeServicesLive = layer$69.pipe(Layer.provideMerge(layer$1), Layer.provideMerge(AssetSyncLive), Layer.provideMerge(RuntimeDependenciesLive));
 const makeRoutesLayer = Layer.mergeAll(Layer.mergeAll(HttpApiBuilder.layer(EnvironmentHttpApi).pipe(Layer.provide(authHttpApiLayer), Layer.provide(orchestrationHttpApiLayer), Layer.provide(pullRequestHttpApiLayer), Layer.provide(serverEnvironmentHttpApiLayer), Layer.provide(environmentAuthenticatedAuthLayer)), otlpTracesProxyRouteLayer, assetRouteLayer, mcpOAuthCallbackRouteLayer, staticAndDevRouteLayer, websocketRpcRouteLayer), layer$4.pipe(Layer.provide(layer$6)), layer$65, layer).pipe(Layer.provide(ProjectionProjectRepositoryLive.pipe(Layer.provide(PersistenceLayerLive))), Layer.provide(ProjectionThreadRepositoryLive.pipe(Layer.provide(PersistenceLayerLive))), Layer.provide(layer$64), Layer.provide(layer$25), Layer.provide(PullRequestServiceLive), Layer.provide(layer$20), Layer.provide(layer$75), Layer.provide(browserApiCorsLayer), Layer.provide(httpCompressionLayer));
 const makeServerLayer = Layer.unwrap(Effect.gen(function* () {
 	const config = yield* ServerConfig$1;