Solver switch: reconnect after the restart, and narrate it

packages/app/src/components/amicode-defaults-capsule.tsx

@@ -12,6 +12,7 @@ import {
   solverConnectionDot,
   type SolverMode,
 } from "@opencode-ai/ui/amicode-solver-toggle"
+import { beginSolverSwitch } from "@/components/solver-switch-banner"
 import {
   ConnectionCard,
   type ConnectionActionView,
@@ -112,7 +113,12 @@ export function AmicodeDefaultsCapsule(props: { compute?: AmicodeComputeControl
   }
   const submitCredential = async (payload: CredentialSubmitPayload) => {
     const result = await props.compute!.onSubmit(payload)
-    if (hpAfterConnect(result)) pick("hp")
+    if (hpAfterConnect(result)) {
+      // #167 writes {mode:"hp",status:"switching"} on this same valid outcome,
+      // so the restart starts here — narrate it (opencode#78 follow-up).
+      beginSolverSwitch("hp")
+      pick("hp")
+    }
     return result
   }
   const disconnectCompute = (id: string) => {

packages/app/src/components/solver-switch-banner.tsx

@@ -0,0 +1,99 @@
+import { Show, createEffect, createSignal, onCleanup } from "solid-js"
+import {
+  solverSwitchExpired,
+  solverSwitchLabel,
+  solverSwitchPhase,
+  type SolverSwitchPhase,
+} from "@opencode-ai/ui/amicode-solver-switch"
+import type { SolverMode } from "@opencode-ai/ui/amicode-solver-toggle"
+import { useServerSDK } from "@/context/server-sdk"
+
+// Amicode: the visible half of a solver switch (opencode#78 follow-up).
+//
+// #221 made the switch REAL — the extension watcher re-preps the session config
+// and restarts the opencode server. The webview survives that; its SSE stream
+// does not. Nothing narrated the gap, so a deliberate tier change looked like a
+// hang (the reconnect loop retries silently, which reads as an endless
+// "thinking" wave).
+//
+// Scope is deliberately narrow. The old ConnectionBanner spoke for EVERY drop
+// and was unmounted on 2026-08-07 (f696388/a03aa04) after opencode#132's stuck
+// pill; this one only ever speaks for a switch the app itself requested, so it
+// cannot get stuck on a transient blip and does not reinstate that decision.
+
+// Module-level: the two call sites that can start a switch live in different
+// component trees (the popover's connections state and the home chrome's), and
+// both must reach the one banner in the layout.
+const [target, setTarget] = createSignal<SolverMode | undefined>()
+const [startedAt, setStartedAt] = createSignal(0)
+
+/** Announce a switch the app just requested. `hp` rides a validated credential,
+ *  `piccolo` rides POST /amicode/solver-mode — this only mirrors that request,
+ *  it never causes one. */
+export function beginSolverSwitch(mode: SolverMode) {
+  setTarget(mode)
+  setStartedAt(Date.now())
+}
+
+function endSolverSwitch() {
+  setTarget(undefined)
+  setStartedAt(0)
+}
+
+export function SolverSwitchBanner() {
+  const sdk = useServerSDK()
+  const [sawDrop, setSawDrop] = createSignal(false)
+  const [elapsed, setElapsed] = createSignal(0)
+
+  // One clock, alive only while a switch is outstanding: it drives the expiry
+  // check, which has nothing else to react to (the stall case is defined by the
+  // absence of any status change).
+  createEffect(() => {
+    if (!target()) {
+      setSawDrop(false)
+      setElapsed(0)
+      return
+    }
+    const timer = setInterval(() => setElapsed(Date.now() - startedAt()), 500)
+    onCleanup(() => clearInterval(timer))
+  })
+
+  // Latch the drop: once the server has gone down, coming back up is the
+  // switch completing rather than the request still waiting to be picked up.
+  createEffect(() => {
+    if (target() && sdk().event.status() === "disconnected") setSawDrop(true)
+  })
+
+  const phase = (): SolverSwitchPhase =>
+    solverSwitchPhase({
+      target: target(),
+      connected: sdk().event.status() === "connected",
+      sawDrop: sawDrop(),
+    })
+
+  createEffect(() => {
+    const current = phase()
+    if (current === "idle") return
+    // Hold the completed chip briefly — it is the only confirmation the user
+    // gets inside the app, and the extension's toast lands outside the webview.
+    if (current === "ready") {
+      const done = setTimeout(endSolverSwitch, 3000)
+      onCleanup(() => clearTimeout(done))
+      return
+    }
+    if (solverSwitchExpired(current, elapsed())) endSolverSwitch()
+  })
+
+  const label = () => solverSwitchLabel(phase(), target())
+
+  return (
+    <Show when={label()}>
+      {(text) => (
+        <div data-component="amicode-solver-switch" data-phase={phase()} role="status" aria-live="polite">
+          <i aria-hidden="true" />
+          <span>{text()}</span>
+        </div>
+      )}
+    </Show>
+  )
+}

packages/app/src/components/status-popover-body.tsx

@@ -48,6 +48,7 @@ import { startPrompt } from "@/utils/start-prompt"
 import { authTokenFromCredentials } from "@/utils/server"
 import { GLOBAL_STATUS_DEFAULT_TAB } from "./status-popover-model"
 import { useServerProtocol } from "@/context/server-sdk"
+import { beginSolverSwitch } from "@/components/solver-switch-banner"
 
 const pluginEmptyMessage = (value: string, file: string): JSXElement => {
   const parts = value.split(file)
@@ -692,6 +693,7 @@ export function createAmicodeConnectionsState(shown: Accessor<boolean>) {
   const onSelectPiccolo = () => {
     const conn = server.current
     if (!conn) return
+    beginSolverSwitch("piccolo") // narrate the restart this is about to trigger
     void (async () => {
       try {
         await fetch(new URL("/amicode/solver-mode", conn.http.url), {

packages/app/src/context/server-sdk.test.ts

@@ -1,5 +1,11 @@
 import { describe, expect, test } from "bun:test"
-import { adaptServerEvent, coalesceServerEvents, enqueueServerEvent, resumeStreamAfterPageShow } from "./server-sdk"
+import {
+  adaptServerEvent,
+  applySseError,
+  coalesceServerEvents,
+  enqueueServerEvent,
+  resumeStreamAfterPageShow,
+} from "./server-sdk"
 import type { OpenCodeEvent } from "@opencode-ai/client/promise"
 import type { Event } from "@opencode-ai/sdk/v2/client"
 
@@ -26,6 +32,40 @@ describe("resumeStreamAfterPageShow", () => {
   })
 })
 
+describe("applySseError", () => {
+  const spy = () => {
+    const calls = { disconnect: 0, abort: 0 }
+    return {
+      calls,
+      disconnect: () => calls.disconnect++,
+      abort: () => calls.abort++,
+    }
+  }
+
+  test("a real stream failure ABORTS the attempt, not just marks it disconnected", () => {
+    // The regression: the v1 stream's iterator never throws or completes on
+    // failure, so the reconnect loop only comes round if the attempt is
+    // aborted. Marking disconnected without aborting leaves the client dead on
+    // a server that is already back.
+    const s = spy()
+    expect(applySseError({ closed: false, ...s })).toBe(true)
+    expect(s.calls).toEqual({ disconnect: 1, abort: 1 })
+  })
+
+  test("an already-closed stream is left alone — that is our own abort coming back", () => {
+    const s = spy()
+    expect(applySseError({ closed: true, ...s })).toBe(false)
+    expect(s.calls).toEqual({ disconnect: 0, abort: 0 })
+  })
+
+  test("repeated failures keep aborting — recovery must not depend on a first-error latch", () => {
+    const s = spy()
+    applySseError({ closed: false, ...s })
+    applySseError({ closed: false, ...s })
+    expect(s.calls.abort).toBe(2)
+  })
+})
+
 describe("adaptServerEvent", () => {
   test("preserves V2 events while adapting permission requests for existing consumers", () => {
     const current = {

packages/app/src/context/server-sdk.tsx

@@ -163,6 +163,24 @@ export function resumeStreamAfterPageShow(_event: PageTransitionEvent, start: ()
   start()
 }
 
+/** What an SSE stream error must do, extracted so the ABORT — the part that
+ *  reads as redundant and is easy to delete — is covered by a test.
+ *
+ *  The v1 event stream reports failures through its `onSseError` callback and
+ *  then simply stops yielding: the async iterator neither throws nor completes.
+ *  The reconnect loop only comes round when that iterator ends, so without the
+ *  abort it parks inside `for await` forever and the client stays disconnected
+ *  from a server that is already back — opencode#132's stuck banner, and every
+ *  solver switch since #221, which restarts the server by design.
+ *
+ *  Returns whether this was a real failure, so the caller keeps its log latch. */
+export function applySseError(input: { closed: boolean; disconnect: () => void; abort: () => void }): boolean {
+  if (input.closed) return false
+  input.disconnect()
+  input.abort()
+  return true
+}
+
 type ServerEventEmitter = ReturnType<typeof createGlobalEmitter<{ [key: string]: ServerEvent }>>
 type ServerSDKBase = {
   server: ServerConnection.Any
@@ -282,8 +300,12 @@ function createServerSdkContextBase(server: ServerConnection.Any, scope: ServerS
         try {
           const kind = await protocol
           const onSseError = (error: unknown) => {
-            if (isStreamClosed(error, attempt?.signal)) return
-            setStreamStatus("disconnected")
+            const real = applySseError({
+              closed: isStreamClosed(error, attempt?.signal),
+              disconnect: () => setStreamStatus("disconnected"),
+              abort: () => attempt?.abort(),
+            })
+            if (!real) return
             if (streamErrorLogged) return
             streamErrorLogged = true
             console.error("[global-sdk] event stream error", {

packages/app/src/design-polish.css

@@ -41,6 +41,11 @@
   --font-weight-emphasis: 600; --font-weight-strong: 650;
 
   --border-width: 1px;
+
+  /* ── elevation ── the one float shadow, for transient overlays that sit above
+     the app ground (toasts, the solver-switch banner). Named so it stops being
+     re-invented as a scattered rgba() literal. */
+  --elev-float: 0 8px 24px rgb(0 0 0 / 0.35);
 }
 
 /* ── accent role tokens — per-scheme OPACITY, same hue ──
@@ -127,3 +132,50 @@ button, [role="button"], a, input, textarea, [data-slot="card"] {
 /* the rail: controls use the control corner */
 [data-component="sidebar-rail"] button,
 [data-component="chat-first-rail"] button { border-radius: var(--radius-md); }
+
+
+/* solver-switch banner (opencode#78 follow-up) — narrates the server restart a
+   solver switch triggers. Progress reads NEUTRAL (yellow may never be a
+   foreground on light); completion is the brand chip: --accent fill with
+   near-black --accent-ink, identical in both schemes. */
+[data-component="amicode-solver-switch"] {
+  position: fixed;
+  bottom: var(--space-4);
+  left: 50%;
+  transform: translateX(-50%);
+  z-index: 40;
+  display: flex;
+  align-items: center;
+  gap: var(--space-2);
+  padding: var(--space-2) var(--space-4);
+  border-radius: var(--radius-full);
+  border: var(--border-width) solid var(--v2-border-border-base);
+  background: var(--v2-background-bg-layer-01);
+  color: var(--v2-text-text-base);
+  font-size: var(--font-size-sm);
+  font-weight: var(--font-weight-emphasis);
+  box-shadow: var(--elev-float);
+  transition: background-color 0.16s ease, border-color 0.16s ease, color 0.16s ease;
+}
+[data-component="amicode-solver-switch"][data-phase="ready"] {
+  background: var(--accent);
+  border-color: var(--accent);
+  color: var(--accent-ink);
+}
+/* currentColor, so the dot is neutral ink while switching and near-black on the
+   yellow chip — never a yellow glyph on a light ground. */
+[data-component="amicode-solver-switch"] > i {
+  width: 6px;
+  height: 6px;
+  border-radius: var(--radius-full);
+  background: currentColor;
+  animation: amc-solver-switch-pulse 1.2s ease-in-out infinite;
+}
+[data-component="amicode-solver-switch"][data-phase="ready"] > i {
+  animation: none;
+}
+/* the global prefers-reduced-motion reset above collapses this duration. */
+@keyframes amc-solver-switch-pulse {
+  0%, 100% { opacity: 0.35; }
+  50% { opacity: 1; }
+}

packages/app/src/pages/layout-new.tsx

@@ -2,6 +2,7 @@ import { createEffect, Suspense, type ParentProps } from "solid-js"
 import { createStore } from "solid-js/store"
 import { TabsInfoPopup } from "@/components/help-button"
 import { Titlebar, type TitlebarUpdate } from "@/components/titlebar"
+import { SolverSwitchBanner } from "@/components/solver-switch-banner"
 import { VaultPanel } from "@/components/vault-panel"
 import { usePlatform } from "@/context/platform"
 import { setV2Toast, ToastRegion } from "@/utils/toast"
@@ -46,6 +47,10 @@ export default function NewLayout(props: ParentProps) {
           into layout.tsx's LegacyLayout branch, which newLayoutDesigns never
           reaches (VaultPanel was invisible here). */}
       <VaultPanel />
+      {/* opencode#78 follow-up: a solver switch restarts the opencode server
+          under the webview. Speaks only for switches the app requested — unlike
+          the removed ConnectionBanner, silence is still the default. */}
+      <SolverSwitchBanner />
       {/* DebugBar removed with the fork's debug-bar deletion (kept during the
           upstream merge) — the debugTools toggle state stays for the titlebar's
           channel indicator. */}

packages/ui/src/amicode/solver-switch.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, test } from "bun:test"
+import {
+  SOLVER_SWITCH_MAX_MS,
+  SOLVER_SWITCH_STALL_MS,
+  solverModeName,
+  solverSwitchExpired,
+  solverSwitchLabel,
+  solverSwitchPhase,
+} from "./solver-switch"
+
+describe("solver switch phase", () => {
+  test("no target is idle, connected or not", () => {
+    expect(solverSwitchPhase({ target: undefined, connected: true, sawDrop: false })).toBe("idle")
+    expect(solverSwitchPhase({ target: undefined, connected: false, sawDrop: true })).toBe("idle")
+  })
+
+  test("requested → restarting → ready over one switch", () => {
+    const target = "piccolo" as const
+    expect(solverSwitchPhase({ target, connected: true, sawDrop: false })).toBe("requested")
+    expect(solverSwitchPhase({ target, connected: false, sawDrop: false })).toBe("restarting")
+    expect(solverSwitchPhase({ target, connected: true, sawDrop: true })).toBe("ready")
+  })
+
+  test("a drop while still down stays restarting — sawDrop does not short-circuit it", () => {
+    expect(solverSwitchPhase({ target: "hp", connected: false, sawDrop: true })).toBe("restarting")
+  })
+})
+
+describe("solver switch expiry", () => {
+  test("a request that never drops the server is abandoned", () => {
+    expect(solverSwitchExpired("requested", SOLVER_SWITCH_STALL_MS - 1)).toBe(false)
+    expect(solverSwitchExpired("requested", SOLVER_SWITCH_STALL_MS + 1)).toBe(true)
+  })
+
+  test("a restart gets the full ceiling, not the stall window", () => {
+    expect(solverSwitchExpired("restarting", SOLVER_SWITCH_STALL_MS + 1)).toBe(false)
+    expect(solverSwitchExpired("restarting", SOLVER_SWITCH_MAX_MS + 1)).toBe(true)
+  })
+
+  test("idle and ready never expire — the caller clears those", () => {
+    expect(solverSwitchExpired("idle", SOLVER_SWITCH_MAX_MS * 10)).toBe(false)
+    expect(solverSwitchExpired("ready", SOLVER_SWITCH_MAX_MS * 10)).toBe(false)
+  })
+})
+
+describe("solver switch copy", () => {
+  test("names match the capsule's own labels", () => {
+    expect(solverModeName("hp")).toBe("Piccolissimo + Altissimo")
+    expect(solverModeName("piccolo")).toBe("Piccolo")
+  })
+
+  test("every visible phase reads as an upgrade, never as a fault", () => {
+    expect(solverSwitchLabel("requested", "hp")).toBe("Switching to Piccolissimo + Altissimo…")
+    expect(solverSwitchLabel("restarting", "hp")).toBe("Restarting session server…")
+    expect(solverSwitchLabel("ready", "piccolo")).toBe("Piccolo ready")
+    expect(solverSwitchLabel("restarting", "hp")).not.toMatch(/drop|lost|error|fail/i)
+  })
+
+  test("idle and targetless render nothing", () => {
+    expect(solverSwitchLabel("idle", "hp")).toBeUndefined()
+    expect(solverSwitchLabel("ready", undefined)).toBeUndefined()
+  })
+})