@p4code/cli 0.4.16 → 0.4.18

package/dist/bin.mjs

@@ -260,7 +260,7 @@ const make$115 = () => {
 const layer$118 = Layer.sync(NetService, make$115);
 //#endregion
 //#region package.json
-var version$1 = "0.4.16";
+var version$1 = "0.4.18";
 //#endregion
 //#region src/config.ts
 /**
@@ -1549,6 +1549,7 @@ const ServerSelfUpdateCapability = Schema$1.Literals([
 	"desktop-managed"
 ]);
 const ExecutionEnvironmentCapabilities = Schema$1.Struct({
+	computerUseControls: Schema$1.optionalKey(Schema$1.Boolean),
 	usagePriceOverrides: Schema$1.optionalKey(Schema$1.Boolean),
 	projectAutoPull: Schema$1.optionalKey(Schema$1.Boolean),
 	sharedProjectModelDefault: Schema$1.optionalKey(Schema$1.Boolean),
@@ -9794,6 +9795,11 @@ const LoadBalancingWeights = Schema$1.Record(TrimmedNonEmptyString, Schema$1.Int
 	minimum: 0,
 	maximum: 100
 })));
+const ComputerUsePermissionHosts = Schema$1.Record(TrimmedNonEmptyString, Schema$1.Struct({
+	environmentId: TrimmedNonEmptyString,
+	hostId: TrimmedNonEmptyString,
+	label: Schema$1.optionalKey(TrimmedNonEmptyString)
+}));
 const ClientSettingsSchema = Schema$1.Struct({
 	loadBalancingEnabled: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(false))),
 	loadBalancingWeights: LoadBalancingWeights.pipe(Schema$1.withDecodingDefault(Effect.succeed({}))),
@@ -9805,6 +9811,7 @@ const ClientSettingsSchema = Schema$1.Struct({
 	confirmThreadDelete: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
 	dismissedProviderUpdateNotificationKeys: Schema$1.Array(TrimmedNonEmptyString).pipe(Schema$1.withDecodingDefault(Effect.succeed([]))),
 	diffIgnoreWhitespace: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
+	computerUsePermissionHosts: ComputerUsePermissionHosts.pipe(Schema$1.withDecodingDefault(Effect.succeed({}))),
 	environmentIdentificationMode: EnvironmentIdentificationMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_ENVIRONMENT_IDENTIFICATION_MODE))),
 	glassOpacity: GlassOpacity.pipe(Schema$1.withDecodingDefault(Effect.succeed(80))),
 	favorites: Schema$1.Array(Schema$1.Struct({
@@ -10389,6 +10396,7 @@ Schema$1.Struct({
 	confirmThreadArchive: Schema$1.optionalKey(Schema$1.Boolean),
 	confirmThreadDelete: Schema$1.optionalKey(Schema$1.Boolean),
 	diffIgnoreWhitespace: Schema$1.optionalKey(Schema$1.Boolean),
+	computerUsePermissionHosts: Schema$1.optionalKey(ComputerUsePermissionHosts),
 	environmentIdentificationMode: Schema$1.optionalKey(EnvironmentIdentificationMode),
 	glassOpacity: Schema$1.optionalKey(GlassOpacity),
 	favorites: Schema$1.optionalKey(Schema$1.Array(Schema$1.Struct({
@@ -13338,6 +13346,9 @@ const ComputerUseHost = Schema$1.Struct({
 	nativeApps: Schema$1.Boolean
 });
 const ComputerUseSession = Schema$1.Struct({
+	generationId: Schema$1.optional(TrimmedNonEmptyString),
+	threadTitle: Schema$1.optional(Schema$1.String),
+	environmentLabel: Schema$1.optional(Schema$1.String),
 	environmentId: EnvironmentId,
 	threadId: ThreadId,
 	providerSessionId: TrimmedNonEmptyString,
@@ -13364,7 +13375,9 @@ const ComputerUseHostRequest = Schema$1.Struct({
 	operation: Schema$1.Literals([
 		"js",
 		"js_reset",
-		"close"
+		"close",
+		"stop",
+		"resume"
 	]),
 	input: Schema$1.optional(ComputerUseJsInput)
 });
@@ -13376,10 +13389,15 @@ var ComputerUseError = class extends Schema$1.TaggedErrorClass()("ComputerUseErr
 		"busy",
 		"timeout",
 		"reset",
-		"execution-failed"
+		"execution-failed",
+		"stopped"
 	]),
 	detail: Schema$1.String
-}) {};
+}) {
+	get message() {
+		return this.detail;
+	}
+};
 const ComputerUseHostRegistration = Schema$1.Struct({
 	hostId: TrimmedNonEmptyString,
 	environmentId: EnvironmentId,
@@ -13406,6 +13424,30 @@ const ComputerUseHostResponse = Schema$1.Struct({
 		error: ComputerUseError
 	})])
 });
+const ComputerUseHostReport = Schema$1.Struct({
+	hostId: TrimmedNonEmptyString,
+	connectionId: TrimmedNonEmptyString,
+	session: ComputerUseSession,
+	state: Schema$1.Literals([
+		"active",
+		"closed",
+		"stopped"
+	])
+});
+const ComputerUseControlState = Schema$1.Struct({
+	session: ComputerUseSession,
+	host: ComputerUseHost,
+	state: Schema$1.Literals([
+		"active",
+		"stopping",
+		"stopped",
+		"stop-unconfirmed"
+	])
+});
+const ComputerUseControlInput = Schema$1.Struct({
+	threadId: ThreadId,
+	action: Schema$1.Literals(["stop", "resume"])
+});
 const ComputerUseEnrollmentRequest = Schema$1.Struct({
 	environmentId: EnvironmentId,
 	desktopSessionId: TrimmedNonEmptyString,
@@ -13465,6 +13507,8 @@ const WS_METHODS = {
 	previewReportStatus: "preview.reportStatus",
 	computerUseConnect: "computerUse.connect",
 	computerUseList: "computerUse.list",
+	computerUseControls: "computerUse.controls",
+	computerUseControl: "computerUse.control",
 	computerUseRespond: "computerUse.respond",
 	previewAutomationConnect: "previewAutomation.connect",
 	previewAutomationRespond: "previewAutomation.respond",
@@ -14488,6 +14532,16 @@ const WsComputerUseListRpc = Rpc.make(WS_METHODS.computerUseList, {
 	success: Schema$1.Array(ComputerUseHost),
 	error: EnvironmentAuthorizationError
 });
+const WsComputerUseControlsRpc = Rpc.make(WS_METHODS.computerUseControls, {
+	payload: Schema$1.Struct({}),
+	success: Schema$1.Array(ComputerUseControlState),
+	error: EnvironmentAuthorizationError,
+	stream: true
+});
+const WsComputerUseControlRpc = Rpc.make(WS_METHODS.computerUseControl, {
+	payload: ComputerUseControlInput,
+	error: Schema$1.Union([ComputerUseError, EnvironmentAuthorizationError])
+});
 const WsComputerUseRespondRpc = Rpc.make(WS_METHODS.computerUseRespond, {
 	payload: ComputerUseHostResponse,
 	error: Schema$1.Union([ComputerUseError, EnvironmentAuthorizationError])
@@ -14594,7 +14648,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, 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, 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, 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/contracts/src/deviceCommand.ts
 const MAX_COORDINATE = 32768;
@@ -44553,6 +44607,7 @@ const make$88 = Effect.gen(function* () {
 			connectionProbe: true,
 			pullRequests: true,
 			hostResources: true,
+			computerUseControls: true,
 			deviceSessionLeases: true,
 			deviceActionLeases: true,
 			pullRequestStackActions: true,
@@ -53049,6 +53104,7 @@ const COMPUTER_USE_HELPER_CREDENTIAL_TTL_MS = 300 * 1e3;
 const HELPER_CREDENTIAL_BYTES = 32;
 const MAX_PENDING_REQUESTS = 64;
 const TRANSPORT_GRACE_MS = 2e3;
+const COMPUTER_USE_CONTROL_ACK_TIMEOUT_MS = 5e3;
 const scopeKey = (scope) => JSON.stringify([
 	scope.environmentId,
 	scope.threadId,
@@ -53058,14 +53114,26 @@ const scopeKey = (scope) => JSON.stringify([
 const hostSession = (scope) => ({
 	environmentId: scope.environmentId,
 	threadId: scope.threadId,
+	...scope.threadTitle ? { threadTitle: scope.threadTitle } : {},
 	providerInstanceId: scope.providerInstanceId,
 	providerSessionId: scope.providerSessionId
 });
 var ComputerUseBroker = class extends Context.Service()("@p4code/cli/mcp/ComputerUseBroker") {};
 const layer$67 = Layer.effect(ComputerUseBroker, Effect.gen(function* () {
+	const serviceScope = yield* Scope.Scope;
 	const crypto = yield* Crypto.Crypto;
-	const environmentId = yield* (yield* ServerEnvironment).getEnvironmentId;
+	const environment = yield* ServerEnvironment;
+	const environmentId = yield* environment.getEnvironmentId;
 	const admission = yield* Semaphore.make(1);
+	const controlAdmission = yield* Semaphore.make(1);
+	const states = /* @__PURE__ */ new Map();
+	const stoppedThreads = /* @__PURE__ */ new Set();
+	const controls = yield* SubscriptionRef.make([]);
+	const publish = () => SubscriptionRef.set(controls, [...states.values()]);
+	const stopped = () => new ComputerUseError({
+		reason: "stopped",
+		detail: "Computer Use was stopped by the user. Ask the user to allow Computer Use again before retrying. Resetting cannot restore access."
+	});
 	const connections = /* @__PURE__ */ new Map();
 	const helperCredentials = /* @__PURE__ */ new Map();
 	const leases = /* @__PURE__ */ new Map();
@@ -53084,6 +53152,15 @@ const layer$67 = Layer.effect(ComputerUseBroker, Effect.gen(function* () {
 				detail: "Computer Use host disconnected. Reset before selecting another host."
 			}));
 		}
+		for (const [key, state] of states) {
+			if (state.host.connectionId !== connection.host.connectionId) continue;
+			if (state.state === "active") states.delete(key);
+			else if (state.state === "stopping") states.set(key, {
+				...state,
+				state: "stop-unconfirmed"
+			});
+		}
+		yield* publish();
 		yield* Queue.shutdown(connection.queue);
 	});
 	const revokeHelper = Effect.fn("ComputerUseBroker.revokeHelper")(function* (credential) {
@@ -53143,12 +53220,119 @@ const layer$67 = Layer.effect(ComputerUseBroker, Effect.gen(function* () {
 					requestId,
 					hostId: connection.host.hostId,
 					connectionId: connection.host.connectionId,
-					session: hostSession(scope),
+					session: states.get(key)?.session ?? hostSession(scope),
 					operation: "close"
 				}
 			});
 		}
 	}, admission.withPermits(1));
+	const stopThread = Effect.fn("ComputerUseBroker.stopThread")(function* (threadId) {
+		stoppedThreads.add(threadId);
+		for (const [key, state] of states) {
+			if (state.session.threadId !== threadId) continue;
+			if (state.state !== "stopped") states.set(key, {
+				...state,
+				state: "stopping"
+			});
+			leases.delete(key);
+			for (const [id, request] of pending) {
+				if (request.scopeKey !== key) continue;
+				pending.delete(id);
+				yield* Deferred.fail(request.completion, stopped());
+			}
+		}
+		yield* publish();
+	});
+	const sendControl = Effect.fn("ComputerUseBroker.sendControl")(function* (state, action) {
+		const connection = connections.get(state.host.hostId);
+		if (!connection || action === "stop" && connection.host.connectionId !== state.host.connectionId) {
+			if (action === "resume") return yield* new ComputerUseError({
+				reason: "disconnected",
+				detail: "Reconnect this Mac before allowing Computer Use again. Access remains blocked."
+			});
+			if (state.state === "stopped") return;
+			for (const [key, entry] of states) if (entry.session.threadId === state.session.threadId && entry.host.connectionId === state.host.connectionId) states.set(key, {
+				...entry,
+				state: "stop-unconfirmed"
+			});
+			yield* publish();
+			return yield* new ComputerUseError({
+				reason: "disconnected",
+				detail: "Computer Use host is unreachable. Access is blocked, but the Mac has not confirmed Stop."
+			});
+		}
+		const requestId = yield* crypto.randomUUIDv4.pipe(Effect.orDie);
+		const completion = yield* Deferred.make();
+		pending.set(requestId, {
+			connection,
+			completion,
+			scopeKey: requestId
+		});
+		yield* Effect.gen(function* () {
+			yield* Queue.offer(connection.queue, {
+				type: "request",
+				request: {
+					requestId,
+					hostId: connection.host.hostId,
+					connectionId: connection.host.connectionId,
+					session: state.session,
+					operation: action
+				}
+			});
+			yield* Deferred.await(completion).pipe(Effect.timeout(COMPUTER_USE_CONTROL_ACK_TIMEOUT_MS));
+		}).pipe(Effect.catch(() => disconnect(connection).pipe(Effect.andThen(Effect.fail(new ComputerUseError({
+			reason: "disconnected",
+			detail: "Computer Use host did not confirm the control change. Access remains blocked. Check the Mac before allowing control again."
+		}))))), Effect.ensuring(Effect.sync(() => pending.delete(requestId))));
+	});
+	const report = Effect.fn("ComputerUseBroker.report")(function* (owner, report) {
+		const authorization = yield* authorize(owner);
+		const connection = connections.get(report.hostId);
+		if (!connection || connection.authorization !== authorization || connection.host.connectionId !== report.connectionId || report.session.environmentId !== environmentId) return yield* deny();
+		const key = scopeKey(report.session);
+		const state = states.get(key);
+		if (!state || state.host.connectionId !== report.connectionId || state.session.generationId !== report.session.generationId) return;
+		if (report.state === "stopped") {
+			const others = [...states.values()].filter((entry) => entry.session.threadId === report.session.threadId && entry.state === "active" && entry.host.connectionId !== report.connectionId);
+			yield* stopThread(report.session.threadId);
+			for (const other of new Map(others.map((entry) => [entry.host.connectionId, entry])).values()) yield* sendControl(other, "stop").pipe(Effect.ignore, Effect.forkIn(serviceScope));
+			for (const [entryKey, entry] of states) if (entry.session.threadId === report.session.threadId && entry.host.connectionId === report.connectionId) states.set(entryKey, {
+				...entry,
+				state: "stopped"
+			});
+		} else if (report.state === "closed") {
+			leases.delete(key);
+			if (state.state === "active") states.delete(key);
+			else states.set(key, {
+				...state,
+				state: "stopped"
+			});
+		}
+		if (report.state !== "active") yield* publish();
+	}, admission.withPermits(1));
+	const control = Effect.fn("ComputerUseBroker.control")(function* (input) {
+		const targets = yield* admission.withPermits(1)(Effect.gen(function* () {
+			const targets = [...states.values()].filter((state) => state.session.threadId === input.threadId);
+			if (input.action === "stop" && targets.length > 0) yield* stopThread(input.threadId);
+			return targets;
+		}));
+		const hosts = new Map(targets.map((state) => [state.host.connectionId, state]));
+		let failure;
+		yield* Effect.forEach([...hosts.values()], (state) => sendControl(state, input.action).pipe(Effect.catch((error) => Effect.sync(() => {
+			failure = error;
+		}))), { concurrency: "unbounded" });
+		if (failure) return yield* failure;
+		if (input.action === "resume") stoppedThreads.delete(input.threadId);
+		for (const [key, state] of states) {
+			if (state.session.threadId !== input.threadId) continue;
+			if (input.action === "resume") states.delete(key);
+			else states.set(key, {
+				...state,
+				state: "stopped"
+			});
+		}
+		yield* publish();
+	}, controlAdmission.withPermits(1), Effect.uninterruptible);
 	return ComputerUseBroker.of({
 		attachVerifiedHelper: (binding) => Effect.gen(function* () {
 			if (binding.host.environmentId !== environmentId || !binding.helperIdentity || !binding.desktopSessionId) return yield* deny();
@@ -53210,6 +53394,9 @@ const layer$67 = Layer.effect(ComputerUseBroker, Effect.gen(function* () {
 				expiresAt
 			};
 		}, admission.withPermits(1)),
+		report,
+		control,
+		controls: SubscriptionRef.changes(controls),
 		list: Effect.sync(() => [...connections.values()].map((entry) => entry.host)),
 		connect: (owner, host) => authorize(owner).pipe(Effect.as(Stream.unwrap(Effect.acquireRelease(admission.withPermits(1)(acquire(owner, host)), (connection) => revokeHelper(connection.owner)).pipe(Effect.map((connection) => Stream.fromQueue(connection.queue)))))),
 		respond: Effect.fn("ComputerUseBroker.respond")(function* (owner, response) {
@@ -53225,19 +53412,20 @@ const layer$67 = Layer.effect(ComputerUseBroker, Effect.gen(function* () {
 		invoke: (scope, input, hostId) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
 			const { requestId, connection, completion, request } = yield* admission.withPermits(1)(Effect.gen(function* () {
 				if (scope.authorizationLifetime?.revoked === true || !scope.capabilities.has("computer-use") || scope.environmentId !== environmentId) return yield* deny();
-				if (!scope.computerUseHostId || hostId !== void 0 && hostId !== scope.computerUseHostId) return yield* deny();
-				const grantedHostId = scope.computerUseHostId;
+				if (scope.computerUseHostId && hostId !== void 0 && hostId !== scope.computerUseHostId) return yield* deny();
+				if (stoppedThreads.has(scope.threadId)) return yield* stopped();
+				const grantedHostId = scope.computerUseHostId ?? hostId;
 				const key = scopeKey(scope);
 				const existing = leases.get(key);
 				if (existing && (connections.get(existing.host.hostId) !== existing || hostId !== void 0 && hostId !== existing.host.hostId)) return yield* new ComputerUseError({
 					reason: "disconnected",
 					detail: "Reset Computer Use before changing host connections."
 				});
-				const candidates = [...connections.values()].filter((entry) => (entry.host.browser || entry.host.nativeApps) && entry.host.hostId === grantedHostId);
+				const candidates = [...connections.values()].filter((entry) => (entry.host.browser || entry.host.nativeApps) && (grantedHostId === void 0 || entry.host.hostId === grantedHostId));
 				const connection = existing ?? (candidates.length === 1 ? candidates[0] : void 0);
 				if (!connection) return yield* new ComputerUseError({
 					reason: "unavailable",
-					detail: candidates.length > 1 ? "Select a Computer Use host explicitly." : "No Computer Use host is available."
+					detail: candidates.length > 1 ? `Select a Computer Use host with hostId: ${candidates.map((entry) => `${entry.host.label} (${entry.host.hostId})`).join(", ")}.` : "No Computer Use host is available."
 				});
 				if (pending.size >= MAX_PENDING_REQUESTS || [...pending.values()].some((request) => request.scopeKey === key)) return yield* new ComputerUseError({
 					reason: "busy",
@@ -53246,6 +53434,20 @@ const layer$67 = Layer.effect(ComputerUseBroker, Effect.gen(function* () {
 				yield* authorize(connection.owner);
 				const requestId = yield* crypto.randomUUIDv4.pipe(Effect.orDie);
 				const completion = yield* Deferred.make();
+				const descriptor = yield* environment.getDescriptor;
+				const session = existing ? states.get(key)?.session ?? hostSession(scope) : {
+					...hostSession(scope),
+					environmentLabel: descriptor.label,
+					generationId: requestId
+				};
+				if (!existing) {
+					states.set(key, {
+						session,
+						host: connection.host,
+						state: "active"
+					});
+					yield* publish();
+				}
 				leases.set(key, connection);
 				pending.set(requestId, {
 					connection,
@@ -53260,7 +53462,7 @@ const layer$67 = Layer.effect(ComputerUseBroker, Effect.gen(function* () {
 						requestId,
 						hostId: connection.host.hostId,
 						connectionId: connection.host.connectionId,
-						session: hostSession(scope),
+						session,
 						operation: "js",
 						input
 					}
@@ -53285,7 +53487,7 @@ const layer$67 = Layer.effect(ComputerUseBroker, Effect.gen(function* () {
 				pending.delete(requestId);
 			})));
 		})),
-		reset: (scope) => scope.authorizationLifetime?.revoked !== true && scope.environmentId === environmentId && scope.capabilities.has("computer-use") ? revoke(scope) : Effect.fail(deny()),
+		reset: (scope) => scope.authorizationLifetime?.revoked !== true && scope.environmentId === environmentId && scope.capabilities.has("computer-use") ? stoppedThreads.has(scope.threadId) ? Effect.fail(stopped()) : revoke(scope) : Effect.fail(deny()),
 		revoke,
 		invalidate: (scope) => Effect.sync(() => {
 			if (scope.authorizationLifetime) scope.authorizationLifetime.revoked = true;
@@ -53388,6 +53590,14 @@ const respond = HttpRouter.add("POST", "/internal/computer-use/respond", Effect.
 	yield* broker.respond(bearer(request), response);
 	return HttpServerResponse.empty({ status: 204 });
 }).pipe(Effect.catch(failure$1)));
+const decodeHostReport = Schema$1.decodeUnknownEffect(ComputerUseHostReport);
+const report = HttpRouter.add("POST", "/internal/computer-use/report", Effect.gen(function* () {
+	const request = yield* HttpServerRequest.HttpServerRequest;
+	const broker = yield* ComputerUseBroker;
+	const report = yield* decodeHostReport(yield* request.json);
+	yield* broker.report(bearer(request), report);
+	return HttpServerResponse.empty({ status: 204 });
+}).pipe(Effect.catch(failure$1)));
 const environment = HttpRouter.add("GET", "/internal/computer-use/environment", Effect.gen(function* () {
 	const request = yield* HttpServerRequest.HttpServerRequest;
 	const binding = yield* resolveDesktopBinding(bearer(request));
@@ -53415,7 +53625,7 @@ const renew = HttpRouter.add("POST", "/internal/computer-use/renew", Effect.gen(
 	if (binding.trust) yield* (yield* RemoteComputerUseBindings).touch(bearer(request));
 	return HttpServerResponse.empty({ status: 204 });
 }).pipe(Effect.catch(failure$1)));
-const layer$66 = Layer.mergeAll(exchange, hubForward, hubExchange, connect, respond, environment, renew).pipe(Layer.provide(remoteComputerUseBindingsLayer));
+const layer$66 = Layer.mergeAll(exchange, hubForward, hubExchange, connect, respond, report, environment, renew).pipe(Layer.provide(remoteComputerUseBindingsLayer));
 //#endregion
 //#region src/device/DeviceHubSocketProtocol.ts
 const MAX_DEVICE_INPUT_BYTES = 8 * 1024;
@@ -63291,7 +63501,7 @@ function formatAskUserQuestionAnswers(answers) {
 */
 const FUSION_BUILDER_INSTRUCTIONS = `You are Fusion Builder in an already-created native server pair. Server owns pairing and coordination. Do not inspect or invoke the Fusion skill, create/pair/rename threads, or announce/setup Fusion. Start the user's task directly. Before editing, create and maintain the phase list with your provider's step-tracking tool (Claude Code: TaskCreate for each phase, then TaskUpdate for status, or TodoWrite when that is the tool offered; Codex: update_plan), never the MCP task board tools - one entry per phase in order, exactly one in progress at a time, marked completed at each phase end - so phases render in the task banner. That list holds phase entries only for the whole task; keep step-level or per-file todos out of it. Name each phase in 3-6 words by its outcome, never by a command, file path, or flag, because the banner shows the title verbatim. Prose alone leaves the banner empty. Split it into the fewest substantial phases the task genuinely needs plus a final integration/whole-task phase; most tasks need one to three work phases. Each phase is a complete reviewable slice of behavior. Never split per file, per function, or per trivial step: over-splitting spends review turns instead of finishing the job. Add a phase only when a real review boundary, risky decision, or independent behavior separates the work. Complete exactly one phase per turn, and finish the whole phase in that turn rather than stopping early. Do not run tests, typecheck, lint, or builds per phase; write the tests the change needs, then run verification once in the final phase over the whole task. Exception: a phase whose own correctness is unclear may run the single narrowest check that resolves it. End every phase turn with phase completed, todo status, changed behavior/files, and remaining phases; do not start the next phase in the same turn. Server then wakes the paired Supervisor, which resumes you through ${FUSION_ADVICE_PROMPT_PREFIX}; a user message may also revise or resume the work. Final phase verifies the entire task against the original request and labels it ready for whole-task review. Supervisor is unreachable during your turn. Never spawn/use another Supervisor thread/subagent or attribute Supervisor decisions without ${FUSION_ADVICE_PROMPT_PREFIX}. Within the current phase, continue when straightforward or evidence is clear. For a concrete unresolved tradeoff, correctness risk, or design decision materially needing judgment, stop safely before the risky choice; final response states the exact question and why review is needed. Evaluate/follow Supervisor advice unless conflicting with user request or verified repo state.`;
 const FUSION_WATCHER_TOOL_INSTRUCTIONS = `Supervisor tools belong to the p4-code MCP server: thread_watch_review, thread_watch_events, thread_advise, and thread_gate_respond. If absent from the visible tool list, first use the available tool search/discovery facility to load those exact tools, including provider-prefixed names; absence from the initial list does not establish unavailability. If discovery or a call fails, report the exact missing capability or error and the need to restore the p4-code MCP connection. Do not offer manual relay, draft or implement the task yourself, or abandon the supervisor role as a workaround. For an actionable user requirement, read the relevant builder evidence and relay it through thread_advise; when a gate is open, answer through thread_gate_respond instead.`;
-const FUSION_WATCHER_INSTRUCTIONS = `You are Fusion Supervisor (watcher) in an already-created native server pair. Server owns pairing and coordination and wakes you with ${FUSION_REVIEW_PROMPT_PREFIX} or ${FUSION_GATE_PROMPT_PREFIX} prompts at builder turn boundaries. A plain message outside such a wake may arrive after your conversational memory of the pair is gone; its [fusion-pair] metadata block is authoritative: the builder thread exists and is the counterpart thread id. Never report that no builder thread exists. ${FUSION_WATCHER_TOOL_INSTRUCTIONS} To resume supervision, read builder evidence with thread_watch_review from lastReviewedImplementerSequence, capture its throughSequence on the first page and reuse that fixed bound while paging with nextAfterSequence until hasMore is false (including empty pages). Apply message append/replace operations by identity; recover truncated evidence through targeted raw thread_watch_events source ranges. Retain reviewed requirements and evidence for final review; recover missing context with targeted history reads rather than mandatory raw replay from zero, derive phase from artifacts (git log/status, PR, builder events, including its turn.plan.updated phase list), steer with thread_advise, and answer an open gate with thread_gate_respond. When a review or gate wake prompt specifies an explicit event range, that range wins over this metadata. Never poll or wait for the builder; deliver review or advice, then end the turn. Every thread_advise starts a builder turn whose completion wakes you again, so never advise a builder that is idle on an external wait or has nothing actionable; report the state in your own thread and end without advising.`;
+const FUSION_WATCHER_INSTRUCTIONS = `You are Fusion Supervisor (watcher) in an already-created native server pair. Server owns pairing and coordination and wakes you with ${FUSION_REVIEW_PROMPT_PREFIX} or ${FUSION_GATE_PROMPT_PREFIX} prompts at builder turn boundaries. A plain message outside such a wake may arrive after your conversational memory of the pair is gone; its [fusion-pair] metadata block is authoritative: the builder thread exists and is the counterpart thread id. Never report that no builder thread exists. For a new pair, the initial user request is yours: inspect the task and available project context, plan the work, then direct the first actionable phase to the idle builder through thread_advise. Include the original requirements, constraints, and authorized delivery scope in that direction. The builder has not received the initial prompt and must not start before your direction. Missing builder turn evidence is expected before that first direction; do not wait for it or implement the work yourself. Ask the user only when needed to resolve a blocking requirement. ${FUSION_WATCHER_TOOL_INSTRUCTIONS} To resume supervision, read builder evidence with thread_watch_review from lastReviewedImplementerSequence, capture its throughSequence on the first page and reuse that fixed bound while paging with nextAfterSequence until hasMore is false (including empty pages). Apply message append/replace operations by identity; recover truncated evidence through targeted raw thread_watch_events source ranges. Retain reviewed requirements and evidence for final review; recover missing context with targeted history reads rather than mandatory raw replay from zero, derive phase from artifacts (git log/status, PR, builder events, including its turn.plan.updated phase list), steer with thread_advise, and answer an open gate with thread_gate_respond. When a review or gate wake prompt specifies an explicit event range, that range wins over this metadata. Never poll or wait for the builder; deliver review or advice, then end the turn. Every thread_advise starts a builder turn whose completion wakes you again, so never advise a builder that is idle on an external wait or has nothing actionable; report the state in your own thread and end without advising.`;
 /**
 * The one-line stand-in for the full block on a message whose session already
 * carries the role instructions.
@@ -124607,6 +124817,8 @@ const RPC_REQUIRED_SCOPE = /* @__PURE__ */ new Map([
 	[WS_METHODS.previewReportStatus, AuthOrchestrationOperateScope],
 	[WS_METHODS.computerUseConnect, AuthOrchestrationOperateScope],
 	[WS_METHODS.computerUseList, AuthOrchestrationReadScope],
+	[WS_METHODS.computerUseControls, AuthOrchestrationReadScope],
+	[WS_METHODS.computerUseControl, AuthOrchestrationOperateScope],
 	[WS_METHODS.computerUseRespond, AuthOrchestrationOperateScope],
 	[WS_METHODS.previewAutomationConnect, AuthOrchestrationOperateScope],
 	[WS_METHODS.previewAutomationRespond, AuthOrchestrationOperateScope],
@@ -125041,6 +125253,18 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker, computerUseBrok
 					branch: worktree.worktree.refName,
 					worktreePath: targetWorktreePath
 				});
+				if (!bootstrap.createThread) {
+					const snapshot = yield* projectionSnapshotQuery.getCommandReadModel();
+					const pair = snapshot.threadPairs?.find((candidate) => candidate.detachedAt === null && candidate.watcherThreadId === command.threadId);
+					const builder = pair && snapshot.threads.find((thread) => thread.id === pair.implementerThreadId && thread.deletedAt === null);
+					if (builder && builder.latestTurn === null && builder.messages.length === 0 && builder.worktreePath === null) yield* orchestrationEngine.dispatch({
+						type: "thread.meta.update",
+						commandId: yield* serverCommandId("bootstrap-builder-meta-update"),
+						threadId: builder.id,
+						branch: worktree.worktree.refName,
+						worktreePath: targetWorktreePath
+					});
+				}
 				yield* refreshGitStatus(targetWorktreePath);
 			}
 			yield* runSetupProgram();
@@ -125632,6 +125856,8 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker, computerUseBrok
 		[WS_METHODS.previewList]: (input) => observeRpcEffect$1(WS_METHODS.previewList, previewManager.list(input), { "rpc.aggregate": "preview" }),
 		[WS_METHODS.previewReportStatus]: (input) => observeRpcEffect$1(WS_METHODS.previewReportStatus, previewManager.reportStatus(input), { "rpc.aggregate": "preview" }),
 		[WS_METHODS.computerUseList]: () => computerUseBroker.list,
+		[WS_METHODS.computerUseControls]: () => computerUseBroker.controls,
+		[WS_METHODS.computerUseControl]: (input) => computerUseBroker.control(input),
 		[WS_METHODS.computerUseConnect]: () => Effect.fail(new ComputerUseError({
 			reason: "denied",
 			detail: "Ordinary environment clients cannot register Computer Use helpers."
@@ -126105,7 +126331,7 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 		const providerSessionId = yield* crypto.randomUUIDv4.pipe(Effect.orDie);
 		const rawToken = yield* crypto.randomBytes(32).pipe(Effect.map(tokenFromBytes), Effect.orDie);
 		const tokenHash = yield* hashToken(rawToken);
-		const computerUseToken = request.computerUseHostId ? yield* crypto.randomBytes(32).pipe(Effect.map(tokenFromBytes), Effect.orDie) : void 0;
+		const computerUseToken = request.computerUseAccess || request.computerUseHostId ? yield* crypto.randomBytes(32).pipe(Effect.map(tokenFromBytes), Effect.orDie) : void 0;
 		const computerUseHash = computerUseToken ? yield* hashToken(computerUseToken) : void 0;
 		const watchThreadIds = new Set((request.watchThreadIds ?? []).map((threadId) => ThreadId.make(threadId)));
 		const adviseThreadIds = new Set((request.adviseThreadIds ?? []).map((threadId) => ThreadId.make(threadId)));
@@ -126127,6 +126353,7 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 			},
 			environmentId,
 			threadId,
+			...request.threadTitle ? { threadTitle: request.threadTitle } : {},
 			providerSessionId,
 			providerInstanceId: ProviderInstanceId.make(request.providerInstanceId),
 			capabilities,
@@ -126144,12 +126371,12 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 				controlThreadIds: /* @__PURE__ */ new Set(),
 				lastAliveAt: issuedAt
 			});
-			if (computerUseHash && request.computerUseHostId) next.set(computerUseHash, {
+			if (computerUseHash) next.set(computerUseHash, {
 				tokenHash: computerUseHash,
 				scope: {
 					...scopeWith(false, false, computerRevocation),
 					capabilities: /* @__PURE__ */ new Set(["computer-use"]),
-					computerUseHostId: request.computerUseHostId
+					...request.computerUseHostId ? { computerUseHostId: request.computerUseHostId } : {}
 				},
 				controlThreadIds: /* @__PURE__ */ new Set(),
 				lastAliveAt: issuedAt
@@ -126481,16 +126708,14 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (options)
 			const thread = yield* projectionQuery.value.getThreadShellById(threadId);
 			return Option.isSome(thread) ? resolveProjectAgentBrowserAccess(settings, thread.value.projectId) : false;
 		})), Effect.catch((cause) => Effect.logWarning("Could not read settings; withholding agent browser access.", { cause }).pipe(Effect.as(false))));
-		const computerUseHostId = yield* Effect.gen(function* () {
-			if ((yield* registry.getInstanceInfo(providerInstanceId)).driverKind === "codex" || Option.isNone(projectionQuery)) return void 0;
-			const thread = yield* projectionQuery.value.getThreadShellById(threadId);
-			return Option.isSome(thread) ? thread.value.computerUseHostId ?? void 0 : void 0;
-		}).pipe(Effect.catch(() => Effect.void));
+		const computerUseAccess = yield* registry.getInstanceInfo(providerInstanceId).pipe(Effect.map((info) => info.driverKind !== "codex"), Effect.catch(() => Effect.succeed(false)));
+		const threadTitle = Option.isSome(projectionQuery) ? yield* projectionQuery.value.getThreadShellById(threadId).pipe(Effect.map((thread) => Option.isSome(thread) ? thread.value.title : void 0), Effect.catch(() => Effect.succeed(void 0))) : void 0;
 		const credential = yield* issueActiveMcpCredential({
 			threadId,
+			...threadTitle ? { threadTitle } : {},
 			providerInstanceId,
 			browserAccess,
-			...computerUseHostId ? { computerUseHostId } : {},
+			computerUseAccess,
 			...watchThreadIds !== void 0 ? { watchThreadIds } : {},
 			...adviseThreadIds !== void 0 ? { adviseThreadIds } : {}
 		});
@@ -127279,6 +127504,25 @@ const makeProviderSessionReaper = (options) => Effect.gen(function* () {
 const makeProviderSessionReaperLive = (options) => Layer.effect(ProviderSessionReaper, makeProviderSessionReaper(options));
 const ProviderSessionReaperLive = makeProviderSessionReaperLive();
 //#endregion
+//#region src/mcp/McpToolkit.ts
+const mcpInputSchema = (schema) => ({
+	...schema,
+	type: "object"
+});
+const mcpToolkit = (toolkit) => Layer.effectDiscard(Effect.gen(function* () {
+	const server = yield* McpServer.McpServer;
+	yield* McpServer.registerToolkit(toolkit).pipe(Effect.provideService(McpServer.McpServer, {
+		...server,
+		addTool: (options) => server.addTool({
+			...options,
+			tool: new McpSchema.Tool({
+				...options.tool,
+				inputSchema: mcpInputSchema(options.tool.inputSchema)
+			})
+		})
+	}));
+}));
+//#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 getState(), activate(), click({elementId}), or type({elementId,text}) to replace a field value. Element IDs come from the latest app snapshot. List windows with app.windows(); capture a listed ID with app.screenshot(windowId), then nodeRepl.emitImage(image). 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.",
@@ -127320,7 +127564,7 @@ const register = Effect.fn("computerUse.register")(function* () {
 		tool: new McpSchema.Tool({
 			name: tool.name,
 			description: Tool.getDescription(tool),
-			inputSchema: Tool.getJsonSchema(tool),
+			inputSchema: mcpInputSchema(Tool.getJsonSchema(tool)),
 			annotations: {
 				readOnlyHint: false,
 				destructiveHint: true,
@@ -127711,7 +127955,7 @@ const registerScreenshot = Effect.fn("device.registerScreenshot")(function* () {
 		tool: new McpSchema.Tool({
 			name: DeviceScreenshotTool.name,
 			description: Tool.getDescription(DeviceScreenshotTool),
-			inputSchema: Tool.getJsonSchema(DeviceScreenshotTool),
+			inputSchema: mcpInputSchema(Tool.getJsonSchema(DeviceScreenshotTool)),
 			annotations: {
 				readOnlyHint: true,
 				destructiveHint: false,
@@ -127729,7 +127973,7 @@ const registerScreenshot = Effect.fn("device.registerScreenshot")(function* () {
 		}))))
 	});
 });
-const DeviceToolkitRegistrationLive = Layer.mergeAll(McpServer.toolkit(DeviceStandardToolkit), Layer.effectDiscard(registerScreenshot())).pipe(Layer.provide(DeviceToolkitHandlersLive));
+const DeviceToolkitRegistrationLive = Layer.mergeAll(mcpToolkit(DeviceStandardToolkit), Layer.effectDiscard(registerScreenshot())).pipe(Layer.provide(DeviceToolkitHandlersLive));
 //#endregion
 //#region src/mcp/toolkits/preview/tools.ts
 const dependencies$1 = [McpInvocationContext, PreviewAutomationBroker];
@@ -128467,7 +128711,7 @@ const AskUserQuestionTool = Tool.make("ask_user_question", {
 	]
 }).annotate(Tool.Title, "Ask user question").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, false);
 const ThreadSpawnTool = Tool.make("thread_spawn", {
-	description: "Start a new agent thread and send it a first message, then return its id. Use it to hand a piece of work to a fresh thread - a subtask you just planned, a job that wants its own transcript. Set fusion true to create two new threads as a separate Fusion pair and start its builder with prompt, even when this thread already belongs to a pair. Set fusionWatcher true only for a supervisor to pair with the current thread. Both use saved Fusion role models unless overridden. Act on the user's request; no special command syntax is required. The new thread inherits this one's project, model, permission mode, interaction mode, compression and subagent policy, and every one of those can be set here instead - what you set is already in force for the first turn, so a thread never has to be corrected after it starts. Set modelSelection to run it on another model: give the model id, and leave instanceId out to keep this thread's provider instance. Once started it can be watched with thread_watch_events and changed later with thread_configure. A thread that was itself started this way cannot start another.",
+	description: "Start a new agent thread and send it a first message, then return its id. Use it to hand a piece of work to a fresh thread - a subtask you just planned, a job that wants its own transcript. Set fusion true to create two new threads as a separate Fusion pair and send prompt to its supervisor, which plans and directs the builder later, even when this thread already belongs to a pair. Set fusionWatcher true only for a supervisor to pair with the current thread. Both use saved Fusion role models unless overridden. Act on the user's request; no special command syntax is required. The new thread inherits this one's project, model, permission mode, interaction mode, compression and subagent policy, and every one of those can be set here instead - what you set is already in force for the first turn, so a thread never has to be corrected after it starts. Set modelSelection to run it on another model: give the model id, and leave instanceId out to keep this thread's provider instance. Once started it can be watched with thread_watch_events and changed later with thread_configure. A thread that was itself started this way cannot start another.",
 	parameters: ThreadSpawnInput,
 	success: ThreadSpawnResult,
 	failure: ThreadControlToolError,
@@ -128871,21 +129115,21 @@ const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
 		yield* dispatchControl({
 			type: "thread.turn.start",
 			commandId: yield* newCommandId,
-			threadId,
+			threadId: fusionPair?.watcherThreadId ?? threadId,
 			message: {
 				messageId: MessageId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie)),
 				role: "user",
 				text: input.prompt,
 				attachments: []
 			},
-			modelSelection,
+			modelSelection: fusionPair ? settings?.fusionWatcherModelSelection ?? modelSelection : modelSelection,
 			titleSeed: input.title,
 			runtimeMode,
-			interactionMode,
+			interactionMode: fusionPair ? "default" : interactionMode,
 			compressMode,
 			unpromptedSubagents,
 			createdAt
-		}, threadId);
+		}, fusionPair?.watcherThreadId ?? threadId);
 		return {
 			threadId,
 			projectId,
@@ -129525,7 +129769,7 @@ const registerPreviewSnapshot = Effect.fn("McpHttpServer.registerPreviewSnapshot
 		tool: new McpSchema.Tool({
 			name: tool.name,
 			description: Tool.getDescription(tool),
-			inputSchema: Tool.getJsonSchema(tool),
+			inputSchema: mcpInputSchema(Tool.getJsonSchema(tool)),
 			annotations: {
 				...Context.getOption(tool.annotations, Tool.Title).pipe(Option.map((title) => ({ title })), Option.getOrUndefined),
 				readOnlyHint: Context.get(tool.annotations, Tool.Readonly),
@@ -129567,13 +129811,13 @@ const registerPreviewSnapshot = Effect.fn("McpHttpServer.registerPreviewSnapshot
 		})
 	});
 });
-const PreviewStandardToolkitRegistrationLive = McpServer.toolkit(PreviewStandardToolkit).pipe(Layer.provide(PreviewStandardToolkitHandlersLive));
+const PreviewStandardToolkitRegistrationLive = mcpToolkit(PreviewStandardToolkit).pipe(Layer.provide(PreviewStandardToolkitHandlersLive));
 const PreviewSnapshotRegistrationLive = Layer.effectDiscard(registerPreviewSnapshot()).pipe(Layer.provide(PreviewSnapshotToolkitHandlersLive));
 const PreviewToolkitRegistrationLive = Layer.mergeAll(PreviewStandardToolkitRegistrationLive, PreviewSnapshotRegistrationLive);
-const TaskToolkitRegistrationLive = McpServer.toolkit(TaskToolkit).pipe(Layer.provide(TaskToolkitHandlersLive));
-const ThreadToolkitRegistrationLive = McpServer.toolkit(ThreadToolkit).pipe(Layer.provide(ThreadToolkitHandlersLive));
-const WatchToolkitRegistrationLive = McpServer.toolkit(WatchToolkit).pipe(Layer.provide(WatchToolkitHandlersLive));
-const AdviseToolkitRegistrationLive = McpServer.toolkit(AdviseToolkit).pipe(Layer.provide(AdviseToolkitHandlersLive));
+const TaskToolkitRegistrationLive = mcpToolkit(TaskToolkit).pipe(Layer.provide(TaskToolkitHandlersLive));
+const ThreadToolkitRegistrationLive = mcpToolkit(ThreadToolkit).pipe(Layer.provide(ThreadToolkitHandlersLive));
+const WatchToolkitRegistrationLive = mcpToolkit(WatchToolkit).pipe(Layer.provide(WatchToolkitHandlersLive));
+const AdviseToolkitRegistrationLive = mcpToolkit(AdviseToolkit).pipe(Layer.provide(AdviseToolkitHandlersLive));
 const McpTransportLive = McpServer.layerHttp({
 	name: "P4Code",
 	version: version$1,
@@ -129585,7 +129829,7 @@ const ComputerUseMcpLive = ComputerUseToolkitRegistrationLive.pipe(Layer.provide
 	version: version$1,
 	path: "/mcp/computer-use"
 }).pipe(Layer.provide(McpAuthMiddlewareLive))));
-const layer$3 = Layer.mergeAll(StandardMcpLive, ComputerUseMcpLive);
+const layer$3 = Layer.mergeAll(Layer.fresh(StandardMcpLive), Layer.fresh(ComputerUseMcpLive));
 //#endregion
 //#region src/hub/HubActivityTransport.ts
 const REQUEST_TIMEOUT_MS = 8e3;