P2: découverte & reprise des sessions Claude

Arboretum découvre désormais toutes les sessions Claude de la machine
(scan ~/.claude/projects + registre ~/.claude/sessions), distingue
vivantes/mortes par pid+procStart, et permet de reprendre une morte
(--resume dans son cwd d'origine) ou forker une vivante sans la corrompre.

- shared: SessionSummary enrichi (source, claudeSessionId, pid, resumable,
  attachable, registryStatus) — additif, PROTOCOL_VERSION inchangé ;
  types REST resume/fork.
- db: migration id:2 (claude_session_id, resumed_from).
- core: jsonl-discovery (parseur tolérant, scan asynchrone non bloquant),
  session-registry (vivacité pid+procStart), discovery-service (cache +
  refresh périodique + diff/broadcast), pty-manager (resume/fork + capture
  du claudeSessionId via le registre).
- routes: /sessions/:id/resume (garde-fou 409 anti-corruption sur session
  vivante) et /fork ; GET fusionné managées + découvertes ; relais WS.
- web: badges managed/discovered + busy/idle/waiting, actions conditionnelles
  (Open/Observe/Kill vs Fork/View vs Resume/Fork), vue read-only des sessions
  externes, i18n EN/FR.
- tests: jsonl-discovery, session-registry, discovery-service + resume/fork
  (130 verts) ; acceptation E2E acceptance-p2.mjs (sans quota) ALL GREEN.

Conforme aux verdicts S1 (resume dans cwd d'origine, vivacité pid+procStart)
et S4 (munge cwd, parseur tête+queue, priorité de titre).

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

packages/server/src/routes/sessions.ts

@@ -1,10 +1,11 @@
 import type { FastifyInstance } from 'fastify';
 import type { CreateSessionRequest, SessionResponse, SessionsListResponse } from '@arboretum/shared';
 import type { PtyManager } from '../core/pty-manager.js';
+import { mergeSessions, type DiscoveryService } from '../core/discovery-service.js';
 
-export function registerSessionRoutes(app: FastifyInstance, manager: PtyManager): void {
+export function registerSessionRoutes(app: FastifyInstance, manager: PtyManager, discovery: DiscoveryService): void {
   app.get('/api/v1/sessions', async (): Promise<SessionsListResponse> => {
-    return { sessions: manager.list() };
+    return { sessions: mergeSessions(manager.list(), discovery.list()) };
   });
 
   app.post('/api/v1/sessions', async (req, reply) => {
@@ -25,6 +26,45 @@ export function registerSessionRoutes(app: FastifyInstance, manager: PtyManager)
     }
   });
 
+  // Reprise d'une session morte : nouveau PTY managé `--resume <id>` DANS SON CWD D'ORIGINE (spike S1).
+  // Le cwd n'est jamais fourni par le client : il est lu sur disque via la découverte.
+  app.post('/api/v1/sessions/:id/resume', async (req, reply) => {
+    const { id } = req.params as { id: string };
+    const discovered = discovery.getDiscovered(id);
+    if (!discovered) {
+      return reply.status(404).send({ error: { code: 'NOT_FOUND', message: 'No resumable session with this id' } });
+    }
+    // Garde-fou anti-corruption : jamais de resume direct d'une session vivante (vérif FRAÎCHE).
+    if (discovery.isClaudeSessionLive(id) || manager.findLiveByClaudeSessionId(id)) {
+      return reply.status(409).send({ error: { code: 'SESSION_LIVE', message: 'Session is live — fork it instead' } });
+    }
+    try {
+      const session = manager.spawn({ cwd: discovered.cwd, resume: { claudeSessionId: id } });
+      const res: SessionResponse = { session };
+      return reply.status(201).send(res);
+    } catch (err) {
+      const statusCode = (err as { statusCode?: number }).statusCode ?? 500;
+      return reply.status(statusCode).send({ error: { code: 'SPAWN_FAILED', message: (err as Error).message } });
+    }
+  });
+
+  // Fork : duplique une session (vivante ou morte) sans la corrompre (`--resume <id> --fork-session`).
+  app.post('/api/v1/sessions/:id/fork', async (req, reply) => {
+    const { id } = req.params as { id: string };
+    const discovered = discovery.getDiscovered(id);
+    if (!discovered) {
+      return reply.status(404).send({ error: { code: 'NOT_FOUND', message: 'No session with this id to fork' } });
+    }
+    try {
+      const session = manager.spawn({ cwd: discovered.cwd, resume: { claudeSessionId: id, fork: true } });
+      const res: SessionResponse = { session };
+      return reply.status(201).send(res);
+    } catch (err) {
+      const statusCode = (err as { statusCode?: number }).statusCode ?? 500;
+      return reply.status(statusCode).send({ error: { code: 'SPAWN_FAILED', message: (err as Error).message } });
+    }
+  });
+
   app.delete('/api/v1/sessions/:id', async (req, reply) => {
     const { id } = req.params as { id: string };
     if (!manager.kill(id)) {