fix(sessions): guard, gate, and test session reload

Build on the original Reload action with the fixes raised in review:

- Server reload() now refuses to run on archived (read-only) sessions
  and when the session has work in progress, mirroring archive(), so a
  reload can no longer silently abort an in-flight agent run.
- Add a sessions.reload runtime capability; the client gates both the
  reloadSession call and the Reload menu entry on it so the action only
  appears for machines whose Pi-Web runtime supports it.
- reloadSession ignores cached-new and archived sessions.
- Add server (PiSessionService + routes) and client (SessionController)
  tests covering reload success, the active-work guard, archived
  rejection, route forwarding, capability gating, and error mapping.
- Restore alphabetical parser import ordering in clients.ts.
- Add a changeset documenting the feature and the sessiond restart note.

Note: touches a session daemon code path, so pi-web-sessiond.service
must be restarted manually for the server side to take effect.

src/server/sessions/sessionRoutes.test.ts

@@ -97,15 +97,62 @@ describe("session routes", () => {
       await routeApp.close();
     }
   });
+
+  it("reloads a session through the reload route, forwarding workspace context", async () => {
+    const routeApp = Fastify({ logger: false });
+    await routeApp.register(fastifyWebsocket);
+    const eventHub = new SessionEventHub();
+    const routeService = new CapturingRouteSessionService(eventHub);
+    registerSessionRoutes(routeApp, routeService, eventHub);
+
+    try {
+      const requestCwd = resolve("/repo");
+      const reloadResponse = await routeApp.inject({ method: "POST", url: "/sessions/session-1/reload", payload: { cwd: requestCwd } });
+
+      expect(reloadResponse.statusCode).toBe(200);
+      expect(reloadResponse.json()).toEqual({ reloaded: true });
+      expect(routeService.reloadCalls).toEqual([{ id: "session-1", cwd: requestCwd }]);
+    } finally {
+      await routeService.dispose();
+      await routeApp.close();
+    }
+  });
+
+  it("maps reload failures to a mutation error status", async () => {
+    const routeApp = Fastify({ logger: false });
+    await routeApp.register(fastifyWebsocket);
+    const eventHub = new SessionEventHub();
+    const routeService = new CapturingRouteSessionService(eventHub);
+    routeService.reloadError = new Error("Stop current session activity before reloading");
+    registerSessionRoutes(routeApp, routeService, eventHub);
+
+    try {
+      const reloadResponse = await routeApp.inject({ method: "POST", url: "/sessions/session-1/reload", payload: {} });
+
+      expect(reloadResponse.statusCode).toBe(400);
+      expect(reloadResponse.json()).toEqual({ error: "Stop current session activity before reloading" });
+    } finally {
+      await routeService.dispose();
+      await routeApp.close();
+    }
+  });
 });
 
 class CapturingRouteSessionService extends PiSessionService {
   readonly calls: unknown[] = [];
+  readonly reloadCalls: (string | PiSessionRef)[] = [];
+  reloadError: Error | undefined;
 
   constructor(eventHub: SessionEventHub) {
     super(eventHub, { sessionManager: new RejectingSessionManager(), heartbeatIntervalMs: 60_000 });
   }
 
+  override reload(lookup: string | PiSessionRef): Promise<void> {
+    this.reloadCalls.push(lookup);
+    if (this.reloadError !== undefined) return Promise.reject(this.reloadError);
+    return Promise.resolve();
+  }
+
   override status(lookup: string | PiSessionRef) {
     this.calls.push(lookup);
     return Promise.resolve({