fix(web): onboarding Continue no longer locks on computers that won't connect

Continue required every selected computer to be connected, but the wizard
auto-selects every saved computer, including switched-off, offline, failing,
and unsupported ones, and hides saved T3 Connect entries the relay no longer
reports. A single such computer disabled Continue with no way to deselect it.

Continue now enables once a selected computer is connected and no first
connection attempt is still settling; computers that will not connect on
their own are skipped. Switched-off computers are no longer auto-selected.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: juliusmarminge

apps/web/src/components/onboarding/WelcomeWizard.import.test.tsx

@@ -64,7 +64,7 @@ vi.mock("../../state/environments", () => {
     environmentId,
     label: environmentId,
     connection: { phase: "connected" },
-    entry: { target: { _tag: "DirectConnectionTarget" } },
+    entry: { enabled: true, target: { _tag: "DirectConnectionTarget" } },
   });
   const primary = environment("primary");
   return {

apps/web/src/components/onboarding/WelcomeWizard.terminal.test.tsx

@@ -151,6 +151,7 @@ const primaryEnvironment = {
   label: "This computer",
   connection: { phase: "connected" },
   entry: {
+    enabled: true,
     target: new PrimaryConnectionTarget({
       environmentId: primaryId,
       label: "This computer",
@@ -164,6 +165,7 @@ const remoteEnvironment = {
   label: "Paired computer",
   connection: { phase: "connected" },
   entry: {
+    enabled: true,
     target: new BearerConnectionTarget({
       environmentId: remoteId,
       label: "Paired computer",

apps/web/src/components/onboarding/WelcomeWizard.test.tsx

@@ -38,6 +38,7 @@ vi.mock("../../state/environments", () => {
     environmentId: "test-env",
     label: "Computer",
     connection: { phase: "connected" },
+    entry: { enabled: true },
   };
   return {
     useEnvironments: () => ({ environments: [environment] }),

apps/web/src/components/onboarding/WelcomeWizard.tsx

@@ -58,7 +58,10 @@ import { newProjectId, randomUUID } from "../../lib/utils";
 import { agentSessionImport } from "../../state/agentSessions";
 import { readProjects, useProjects } from "../../state/entities";
 import { useEnvironments, usePrimaryEnvironment } from "../../state/environments";
-import { isOnboardingRelayEnvironment } from "../../onboarding/targetEnvironment.logic";
+import {
+  isOnboardingRelayEnvironment,
+  resolveOnboardingSetup,
+} from "../../onboarding/targetEnvironment.logic";
 import { useProjectScans } from "../../onboarding/useProjectScans";
 import { projectEnvironment } from "../../state/projects";
 import { serverEnvironment } from "../../state/server";
@@ -141,11 +144,14 @@ export function WelcomeWizard({
     for (const environment of newComputers) {
       autoSelectedComputers.current.add(environment.environmentId);
     }
+    // A computer the user switched off stays unselected until they pick it.
+    const enabledComputers = newComputers.filter((environment) => environment.entry.enabled);
+    if (enabledComputers.length === 0) return;
     setSelection(
       (current) =>
         new Set([
           ...(current ?? []),
-          ...newComputers.map((environment) => environment.environmentId),
+          ...enabledComputers.map((environment) => environment.environmentId),
         ]),
     );
   }, [environments]);
@@ -262,11 +268,7 @@ export function WelcomeWizard({
                 })
               }
               onContinue={() =>
-                startSetup(
-                  environments
-                    .filter((environment) => selectedIds.has(environment.environmentId))
-                    .map((environment) => environment.environmentId),
-                )
+                startSetup(resolveOnboardingSetup(environments, selectedIds).environmentIds)
               }
               onPaired={(environmentId) => {
                 setSelection(new Set([...selectedIds, environmentId]));
@@ -315,14 +317,7 @@ function ConnectionStep({
   );
   const [pairingOpen, setPairingOpen] = useState(expandPairingInitially);
   const [isPairing, setIsPairing] = useState(false);
-  const ready =
-    selectedIds.size > 0 &&
-    [...selectedIds].every((id) =>
-      environments.some(
-        (environment) =>
-          environment.environmentId === id && environment.connection.phase === "connected",
-      ),
-    );
+  const { ready } = resolveOnboardingSetup(environments, selectedIds);
   const continueRef = useRef<HTMLButtonElement>(null);
   useEffect(() => {
     if (

apps/web/src/onboarding/targetEnvironment.logic.test.ts

@@ -9,6 +9,7 @@ import { describe, expect, it } from "vite-plus/test";
 
 import {
   isOnboardingRelayEnvironment,
+  resolveOnboardingSetup,
   resolveOnboardingTargetEnvironment,
 } from "./targetEnvironment.logic";
 
@@ -209,3 +210,45 @@ describe("isOnboardingRelayEnvironment", () => {
     ).toEqual([olderRelay]);
   });
 });
+
+describe("resolveOnboardingSetup", () => {
+  const computer = (id: string, phase: string) => ({
+    environmentId: EnvironmentId.make(id),
+    connection: { phase },
+  });
+  const local = computer("local", "connected");
+
+  it("skips selected computers that will not connect on their own", () => {
+    const environments = [
+      local,
+      computer("switched-off", "available"),
+      computer("offline", "offline"),
+      computer("failing", "reconnecting"),
+      computer("old-client", "unsupported"),
+    ];
+    expect(
+      resolveOnboardingSetup(
+        environments,
+        new Set(environments.map((environment) => environment.environmentId)),
+      ),
+    ).toEqual({ ready: true, environmentIds: [local.environmentId] });
+  });
+
+  it("waits for a first connection attempt to settle", () => {
+    const connecting = computer("new", "connecting");
+    expect(
+      resolveOnboardingSetup(
+        [local, connecting],
+        new Set([local.environmentId, connecting.environmentId]),
+      ).ready,
+    ).toBe(false);
+  });
+
+  it("is not ready without a connected selection", () => {
+    expect(resolveOnboardingSetup([local], new Set()).ready).toBe(false);
+    expect(
+      resolveOnboardingSetup([computer("off", "available")], new Set([EnvironmentId.make("off")]))
+        .ready,
+    ).toBe(false);
+  });
+});

apps/web/src/onboarding/targetEnvironment.logic.ts

@@ -47,3 +47,21 @@ export function resolveOnboardingTargetEnvironment<TEnvironment extends Onboardi
 
   return mode === "local" ? null : (connectedRelayEnvironments[0] ?? null);
 }
+
+/**
+ * The computers the wizard sets up from the user's selection. Continue waits
+ * only on a first connection attempt, which settles on its own. Selected
+ * computers that are switched off, offline, failing, or unsupported are skipped
+ * so they can never lock the user out of onboarding.
+ */
+export function resolveOnboardingSetup(
+  environments: ReadonlyArray<Pick<OnboardingEnvironment, "environmentId" | "connection">>,
+  selectedIds: ReadonlySet<EnvironmentId>,
+): { readonly ready: boolean; readonly environmentIds: ReadonlyArray<EnvironmentId> } {
+  const selected = environments.filter((environment) => selectedIds.has(environment.environmentId));
+  const environmentIds = selected
+    .filter((environment) => environment.connection.phase === "connected")
+    .map((environment) => environment.environmentId);
+  const settling = selected.some((environment) => environment.connection.phase === "connecting");
+  return { ready: environmentIds.length > 0 && !settling, environmentIds };
+}