Fix the mid-session connect-a-new-provider flow crashing on a live terminal

Choosing "connect a new provider" from the running model picker
called connectProviderInline without a renderer override, so it fell
through to creating its own CliRenderer while the session's own was
still live. Two renderers cannot share one terminal's stdin, so every
real invocation failed with "stdin is already used by another
CliRenderer" — invisible in the existing tests because they always
supply a headless renderer override, masking the default path.

The picker now hands connectProviderInline the session's own
renderer, paused for the duration and resumed on completion, instead
of letting it create one. That required provider-setup's teardown to
stop unconditionally destroying whatever renderer it was given, since
a caller-supplied renderer (a test harness, or here a live session's
own) is owned by that caller, not by the setup form borrowing it.

Author: TheGreatAxios

src/tui-opentui/provider-setup.test.ts

@@ -271,6 +271,19 @@ async function mountLogin(opts: {
   return { done, harness }
 }
 
+describe("runProviderSetup renderer ownership", () => {
+  test("does not destroy a caller-supplied renderer on cancel", async () => {
+    const { done, harness } = await mountSetup()
+    harness.pressKey("Ctrl+C")
+    expect(await done).toBe(false)
+
+    // A caller-owned renderer must still be usable for whatever mounted it
+    // in the first place (a live session resuming its own UI after a
+    // mid-session reconnect), not torn down out from under it.
+    expect(harness.renderer.isDestroyed).toBe(false)
+  })
+})
+
 describe("runProviderSetup sign-in", () => {
   test("a subscription provider signs in in place and persists the selection", async () => {
     const seen: ProviderFormValues[] = []

src/tui-opentui/provider-setup.ts

@@ -605,6 +605,10 @@ const RAMP_TICK_MS = 120
 export async function runProviderSetup(
   config: ProviderSetupConfig,
 ): Promise<boolean> {
+  // A caller-supplied renderer (a headless test harness, or a live session's
+  // renderer reused for a mid-session reconnect) is owned by that caller —
+  // teardown here must not destroy it out from under them.
+  const externalRenderer = config.createRenderer !== undefined
   const renderer = config.createRenderer
     ? await config.createRenderer()
     : await createCliRenderer({
@@ -1075,10 +1079,12 @@ export async function runProviderSetup(
     } catch {
       // already unmounted
     }
-    try {
-      renderer.destroy()
-    } catch {
-      // already destroyed
+    if (!externalRenderer) {
+      try {
+        renderer.destroy()
+      } catch {
+        // already destroyed
+      }
     }
   }
 

src/tui/runner.ts

@@ -1984,20 +1984,30 @@ export async function runTUI(initialConfig: Config): Promise<number> {
     unconnectedProviders: computeUnconnectedProviders(config.providers),
     onConnectProvider: (providerName) => {
       void (async () => {
+        // A second CliRenderer cannot claim the terminal while the host's is
+        // live (they contend for the same stdin) — the setup form reuses the
+        // host's own renderer, paused for the duration and handed back on
+        // completion, rather than creating one of its own.
+        host.renderer.pause();
         let result: Awaited<ReturnType<typeof connectProviderInline>>;
         try {
-          result = await connectProviderInline({
-            providerId: providerName,
-            settingsPath: trueGlobalSettingsPath,
-            localSettingsPath: localSettingsFile,
-            cwd: config.cwd,
-            existing: config.settings ?? null,
-          });
-        } catch (err) {
-          systemRow(
-            `Connecting ${providerName} failed: ${err instanceof Error ? err.message : String(err)}`,
-          );
-          return;
+          try {
+            result = await connectProviderInline({
+              providerId: providerName,
+              settingsPath: trueGlobalSettingsPath,
+              localSettingsPath: localSettingsFile,
+              cwd: config.cwd,
+              existing: config.settings ?? null,
+              createRenderer: () => Promise.resolve(host.renderer),
+            });
+          } catch (err) {
+            systemRow(
+              `Connecting ${providerName} failed: ${err instanceof Error ? err.message : String(err)}`,
+            );
+            return;
+          }
+        } finally {
+          host.renderer.resume();
         }
         if (!result.connected) return;