emrg: the GUI refuses to switch sessions while the current one is streaming #2637

What happens

The GUI has two ways to open a session, and both call the same IPC handler
emrg:switchSession (emrg/gui/preload.js:20 → emrg/gui/main.js:571):

• the sidebar's two-step project → session flow, selectProjectSession
  (renderer/src/components/Shell.tsx:323)
• the task panel's 「打开会话」 button, openTaskSession
  (renderer/src/components/Shell.tsx:332)

While the session that is currently active still has a turn streaming on its connection, the
main process refuses the switch before doing anything else (main.js:587):

// G65：自有流运行中禁止切会话（每连接独立锁，查当前激活连接）
if (connManager?.get(currentSessionId)?.ownStream) {
  logger.warn(`[gui:switch] REJECT own stream in progress (sid=${currentSessionId})`);
  throw new Error("stream in progress — cannot switch");
}

Nothing switches, and the two callers fail in different, both-bad ways:

• Sidebar: await b.switchSession({ sessionId: sid }) has no try/catch, and
  setActiveSid(sid) sits after it. The rejection is an unhandled promise rejection — no
  visible change at all, and a console error the user does not see.
• Task panel: the catch writes t("openSession.loadFailed", …) into activeSid — the
  session being left — and setActiveSid(task.session_id) never runs. The user is
  looking at the task list, so the message lands in a transcript that is not on screen; the
  click looks like it did nothing.

Either way the turn that is running keeps running. The stream is unaffected by the refusal
it caused; only the navigation is blocked.

Why that refusal no longer protects anything

The check comes from a design in which switching a session closed the old connection.
ConnManager.close() sends cancel to a connection whose ownStream is set before
dropping its websocket (emrg/gui/conn-manager.js:129), so allowing a switch would have
quietly killed the turn that was running. Refusing the switch was the safe half of that
pair.

Switching no longer closes anything. A switch opens or reuses the target session's own
connection and deliberately leaves the previous one alone (main.js:625: 「切走不再关闭
旧会话连接」); closing is a separate action, emrg:closeSession. Every session already has
its own websocket and its own transcript bucket, and the daemon runs several sessions
concurrently. So the guard now protects nothing and only refuses: a turn streaming on
session A is unaffected by moving the window to session B, and coming back to A finds it
where it was.

What the fix must satisfy

• Switching sessions is possible at any time, including while the session being left is
  still streaming. Nothing on the switch path refuses on that fact.
• Everything switching does today is unchanged: the previous session's connection stays
  open, its stream keeps writing its own transcript bucket, and returning to it shows the
  turn intact — not restarted, not duplicated.
• emrg:closeSession and ConnManager.close() keep sending cancel before dropping a
  busy connection (conn-manager.js:133). That is the place where a turn would otherwise
  be cut off mid-flight, and it stays exactly as it is.
• The other refusals on this path — invalid session_id, invalid agent path, the
  20-open-session cap (main.js:573–:586) — are untouched; only the ownStream one goes.
• A refusal this path keeps or gains must be visible where the user acted. A message in a
  transcript the user is not looking at, or an unhandled rejection, is exactly what makes a
  click look ignored.
• A regression test holds the property: the handler region no longer reads ownStream,
  and ConnManager.close()'s cancel-before-close still does.

Reading the behaviour

~/.emrg/logs/emrg-gui.log carries one [gui:switch] line per attempt — REQUEST,
REJECT <reason>, openSession OK, DONE. A switch is refused precisely when its attempt
logs REJECT own stream in progress; the control is the same session switching normally
while idle.