From f830079a0e8d9517b30129423f9d17b3ea98d25f Mon Sep 17 00:00:00 2001
From: "Wit, Floris De (178)" <floris_de.wit@mercedes-benz.com>
Date: Thu, 9 Jul 2026 16:15:35 +0200
Subject: [PATCH 1/5] feat(sessions): session-management completeness (fork,
 archive, approvals, pagination)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Rounds out the session lifecycle so a hub session is a fully manageable
"terminal window" (README §6 req #4: list/resume/fork/archive/search) plus two
UX/scale items. No new engine, no scheduling. One additive DB migration (id:4).

Session fork (--fork-session):
- POST /api/sessions/:id/fork copies the parent's config + event log and, on the
  fork's first turn, resumes the parent transcript under a NEW engine session id
  via --fork-session, leaving the parent untouched. A one-shot fork_pending flag
  (migration 4) is consumed on the first engine_meta. SessionManager.fork,
  EventsRepo.copyEvents, createForked, StartOptions.forkSession, SessionDto.parentId.
  Web: fork button in the sidebar. Verified keyless (echo) + live (Claude mints a
  new id and recalls the parent transcript).

Archived-sessions view (backend already existed):
- Sidebar "Show archived" toggle (lazy api.sessions(true)), archive/unarchive
  row action, render-time archivedAt filter, plus a title search filter.

Approval affordances:
- Surface the CLI's permission_suggestions as informational chips in the approval
  card (defensive rendering; no rule persistence). Threaded adapter -> event ->
  timeline -> ApprovalCard.

Replay pagination:
- Bounded initial WS replay (most recent N + replay_meta{hasMoreBefore}); older
  history pages backward over REST (/events?beforeId&limit). Forward catch-up on
  reconnect is unchanged, preserving the atomic replay-then-live invariant. Web:
  "Load earlier" with scroll anchoring.

Tests: +fork and +pagination e2e (echo, keyless); +live fork test (gated).
---
 server/src/api/routes.ts                      |  12 +-
 server/src/api/ws.ts                          |  33 ++++-
 server/src/db/database.ts                     |   9 ++
 server/src/db/repos.ts                        | 101 +++++++++++++++-
 .../src/engines/claude/ClaudeCodeAdapter.ts   |   4 +
 server/src/engines/types.ts                   |   3 +
 server/src/sessions/SessionManager.ts         |  33 +++++
 server/src/sessions/SessionRuntime.ts         |   4 +
 server/test/claude-live.test.ts               |  46 +++++++
 server/test/e2e.test.ts                       | 114 ++++++++++++++++++
 shared/src/api.ts                             |   2 +
 shared/src/events.ts                          |   3 +
 shared/src/protocol.ts                        |  12 +-
 web/src/components/ApprovalCard.svelte        |  36 +++++-
 web/src/components/ChatView.svelte            |  37 +++++-
 web/src/components/SessionSidebar.svelte      | 109 ++++++++++++++++-
 web/src/lib/api.ts                            |   6 +
 web/src/lib/format.ts                         |  33 +++++
 web/src/lib/stores.ts                         |  27 +++++
 web/src/lib/timeline.ts                       |   2 +
 web/src/lib/ws.ts                             |  30 ++++-
 21 files changed, 638 insertions(+), 18 deletions(-)

diff --git a/server/src/api/routes.ts b/server/src/api/routes.ts
index 7407ae1..2c8f662 100644
--- a/server/src/api/routes.ts
+++ b/server/src/api/routes.ts
@@ -66,6 +66,11 @@ export function registerRoutes(app: FastifyInstance, deps: RouteDeps): void {
     return manager.create(body);
   });
 
+  app.post('/api/sessions/:id/fork', async (req) => {
+    const { id } = req.params as { id: string };
+    return manager.fork(id);
+  });
+
   app.get('/api/sessions/:id', async (req, reply) => {
     const { id } = req.params as { id: string };
     const dto = manager.get(id);
@@ -87,7 +92,12 @@ export function registerRoutes(app: FastifyInstance, deps: RouteDeps): void {
   app.get('/api/sessions/:id/events', async (req, reply) => {
     const { id } = req.params as { id: string };
     if (!manager.get(id)) return reply.code(404).send({ error: 'not_found' });
-    const q = req.query as { afterId?: string };
+    const q = req.query as { afterId?: string; beforeId?: string; limit?: string };
+    // beforeId => backward page (for "load earlier"); otherwise forward from afterId.
+    if (q.beforeId !== undefined) {
+      const limit = q.limit ? Math.min(Number(q.limit), 2000) : 500;
+      return events.listBefore(id, Number(q.beforeId), limit);
+    }
     return events.listAfter(id, q.afterId ? Number(q.afterId) : 0);
   });
 
diff --git a/server/src/api/ws.ts b/server/src/api/ws.ts
index d28b53b..6c27968 100644
--- a/server/src/api/ws.ts
+++ b/server/src/api/ws.ts
@@ -15,6 +15,10 @@ interface WsDeps {
   manager: SessionManager;
 }
 
+/** Events replayed on a bounded initial subscribe; older history pages over REST. */
+const DEFAULT_REPLAY_LIMIT = 500;
+const MAX_REPLAY_LIMIT = 2000;
+
 /**
  * WebSocket hub. Auth-by-first-message, then subscribe/replay per session:
  * persisted events stream from the DB cursor, live events fan out from the
@@ -106,12 +110,33 @@ export function attachWebSocket(server: HttpServer, deps: WsDeps): WebSocketServ
           if (!deps.manager.get(msg.sessionId)) {
             throw new HubError('not_found', 'Session not found');
           }
-          // Replay persisted history from the client's cursor, THEN mark the
-          // subscription live. Replay is synchronous (better-sqlite3), so no
-          // live event can interleave with it.
-          for (const e of deps.events.listAfter(msg.sessionId, msg.afterEventId ?? 0)) {
+          // Replay persisted history, THEN mark the subscription live. Replay is
+          // synchronous (better-sqlite3), so no live event can interleave with it.
+          //  - afterEventId set => forward catch-up (full, bounded by what was missed).
+          //  - omitted          => bounded initial load of the most recent events;
+          //                        older history is fetched lazily over REST.
+          const afterProvided = typeof msg.afterEventId === 'number';
+          let history: SessionEvent[];
+          if (afterProvided) {
+            history = deps.events.listAfter(msg.sessionId, msg.afterEventId as number);
+          } else {
+            const limit =
+              msg.limit && msg.limit > 0
+                ? Math.min(msg.limit, MAX_REPLAY_LIMIT)
+                : DEFAULT_REPLAY_LIMIT;
+            history = deps.events.listRecent(msg.sessionId, limit);
+          }
+          for (const e of history) {
             send({ type: 'event', sessionId: e.sessionId, eventId: e.id, ts: e.ts, event: e.event });
           }
+          // Only the bounded initial load reports whether older history exists;
+          // forward catch-up must not overwrite the client's existing cursor.
+          if (!afterProvided) {
+            const oldestEventId = history.length ? history[0]!.id : null;
+            const hasMoreBefore =
+              oldestEventId !== null && deps.events.hasEventsBefore(msg.sessionId, oldestEventId);
+            send({ type: 'replay_meta', sessionId: msg.sessionId, hasMoreBefore, oldestEventId });
+          }
           subscriptions.add(msg.sessionId);
           const dto = deps.manager.get(msg.sessionId);
           if (dto) send({ type: 'status', sessionId: dto.id, status: dto.status });
diff --git a/server/src/db/database.ts b/server/src/db/database.ts
index 1c1d4b4..dca6410 100644
--- a/server/src/db/database.ts
+++ b/server/src/db/database.ts
@@ -66,6 +66,15 @@ ALTER TABLE sessions ADD COLUMN engine_state TEXT NOT NULL DEFAULT 'new';
 
 UPDATE sessions SET engine_state =
   CASE WHEN engine_session_id IS NOT NULL THEN 'hibernated' ELSE 'new' END;
+`,
+  },
+  {
+    // Session fork: lineage pointer + a one-shot flag consumed on the fork's
+    // first engine start (so --fork-session is passed exactly once).
+    id: 4,
+    sql: `
+ALTER TABLE sessions ADD COLUMN parent_session_id TEXT;
+ALTER TABLE sessions ADD COLUMN fork_pending INTEGER NOT NULL DEFAULT 0;
 `,
   },
 ];
diff --git a/server/src/db/repos.ts b/server/src/db/repos.ts
index 369dd76..10e0a99 100644
--- a/server/src/db/repos.ts
+++ b/server/src/db/repos.ts
@@ -25,6 +25,8 @@ interface SessionRow {
   model: string | null;
   requested_model: string | null;
   settings: string | null;
+  parent_session_id: string | null;
+  fork_pending: number;
 }
 
 function toDto(r: SessionRow): SessionDto {
@@ -45,6 +47,7 @@ function toDto(r: SessionRow): SessionDto {
     model: r.model,
     requestedModel: r.requested_model,
     settings: r.settings,
+    parentId: r.parent_session_id,
   };
 }
 
@@ -71,6 +74,59 @@ export class SessionsRepo {
     return this.get(s.id)!;
   }
 
+  /**
+   * Insert a forked session: seeds the parent's engine session id (so the first
+   * turn resumes it), marks it resumable-but-not-running (`hibernated`), and sets
+   * the one-shot `fork_pending` flag consumed on the fork's first engine start.
+   */
+  createForked(s: {
+    id: string;
+    title: string;
+    engineId: string;
+    cwd: string;
+    permissionMode: PermissionMode | null;
+    model: string | null;
+    settings: string | null;
+    engineSessionId: string;
+    parentSessionId: string;
+  }): SessionDto {
+    const now = Date.now();
+    this.db
+      .prepare(
+        `INSERT INTO sessions
+           (id, title, engine_id, engine_session_id, cwd, permission_mode, requested_model, settings,
+            status, engine_state, fork_pending, parent_session_id, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'idle', 'hibernated', 1, ?, ?, ?)`,
+      )
+      .run(
+        s.id,
+        s.title,
+        s.engineId,
+        s.engineSessionId,
+        s.cwd,
+        s.permissionMode,
+        s.model,
+        s.settings,
+        s.parentSessionId,
+        now,
+        now,
+      );
+    return this.get(s.id)!;
+  }
+
+  /** Whether a forked session still needs --fork-session on its next engine start. */
+  forkPending(id: string): boolean {
+    const row = this.db.prepare('SELECT fork_pending FROM sessions WHERE id = ?').get(id) as
+      | { fork_pending: number }
+      | undefined;
+    return !!row && row.fork_pending !== 0;
+  }
+
+  /** Consume the one-shot fork flag once the fork has its own engine session id. */
+  clearForkPending(id: string): void {
+    this.db.prepare('UPDATE sessions SET fork_pending = 0 WHERE id = ?').run(id);
+  }
+
   get(id: string): SessionDto | undefined {
     const row = this.db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as
       | SessionRow
@@ -170,6 +226,10 @@ interface EventRow {
   payload: string;
 }
 
+function rowToEvent(r: EventRow): SessionEvent {
+  return { id: r.id, sessionId: r.session_id, ts: r.ts, event: JSON.parse(r.payload) as NormalizedEvent };
+}
+
 export class EventsRepo {
   constructor(private db: Database.Database) {}
 
@@ -181,16 +241,45 @@ export class EventsRepo {
     return { id: Number(info.lastInsertRowid), sessionId, ts, event };
   }
 
+  /** Copy a session's event log into another session (used by fork), in id order. */
+  copyEvents(fromSessionId: string, toSessionId: string): void {
+    this.db
+      .prepare(
+        `INSERT INTO events (session_id, ts, type, payload)
+         SELECT ?, ts, type, payload FROM events WHERE session_id = ? ORDER BY id`,
+      )
+      .run(toSessionId, fromSessionId);
+  }
+
   listAfter(sessionId: string, afterId = 0): SessionEvent[] {
     const rows = this.db
       .prepare('SELECT * FROM events WHERE session_id = ? AND id > ? ORDER BY id')
       .all(sessionId, afterId) as EventRow[];
-    return rows.map((r) => ({
-      id: r.id,
-      sessionId: r.session_id,
-      ts: r.ts,
-      event: JSON.parse(r.payload) as NormalizedEvent,
-    }));
+    return rows.map(rowToEvent);
+  }
+
+  /** The most recent `limit` events (ascending) — the bounded initial replay window. */
+  listRecent(sessionId: string, limit: number): SessionEvent[] {
+    const rows = this.db
+      .prepare('SELECT * FROM events WHERE session_id = ? ORDER BY id DESC LIMIT ?')
+      .all(sessionId, limit) as EventRow[];
+    return rows.reverse().map(rowToEvent);
+  }
+
+  /** Up to `limit` events immediately before `beforeId` (ascending) — back-paging. */
+  listBefore(sessionId: string, beforeId: number, limit: number): SessionEvent[] {
+    const rows = this.db
+      .prepare('SELECT * FROM events WHERE session_id = ? AND id < ? ORDER BY id DESC LIMIT ?')
+      .all(sessionId, beforeId, limit) as EventRow[];
+    return rows.reverse().map(rowToEvent);
+  }
+
+  /** Whether any event exists before `beforeId` (used to flag "load earlier"). */
+  hasEventsBefore(sessionId: string, beforeId: number): boolean {
+    const r = this.db
+      .prepare('SELECT 1 FROM events WHERE session_id = ? AND id < ? LIMIT 1')
+      .get(sessionId, beforeId);
+    return r !== undefined;
   }
 
   /**
diff --git a/server/src/engines/claude/ClaudeCodeAdapter.ts b/server/src/engines/claude/ClaudeCodeAdapter.ts
index 7bef54b..e8f1495 100644
--- a/server/src/engines/claude/ClaudeCodeAdapter.ts
+++ b/server/src/engines/claude/ClaudeCodeAdapter.ts
@@ -87,6 +87,9 @@ class ClaudeRun implements EngineRun {
     if (opts.settings) args.push('--settings', opts.settings);
     args.push(...extraArgs);
     if (opts.resumeEngineSessionId) args.push('--resume', opts.resumeEngineSessionId);
+    // Fork the resumed transcript into a new engine session, leaving the parent
+    // intact. Only meaningful together with --resume, and only on the first start.
+    if (opts.forkSession && opts.resumeEngineSessionId) args.push('--fork-session');
 
     const env: NodeJS.ProcessEnv = { ...process.env, ...opts.env };
     for (const k of SCRUBBED_ENV) delete env[k];
@@ -161,6 +164,7 @@ class ClaudeRun implements EngineRun {
           requestId: req.request_id,
           toolName: req.request.tool_name ?? 'unknown',
           input: req.request.input,
+          permissionSuggestions: req.request.permission_suggestions,
         });
       } else {
         // Unknown control request: ack so the CLI doesn't hang.
diff --git a/server/src/engines/types.ts b/server/src/engines/types.ts
index 9a1f90d..9dcf942 100644
--- a/server/src/engines/types.ts
+++ b/server/src/engines/types.ts
@@ -13,6 +13,9 @@ export interface StartOptions {
   settings?: string | null;
   /** Engine-native session id to resume, if any. */
   resumeEngineSessionId?: string;
+  /** Fork the resumed session into a new engine session (Claude --fork-session).
+   *  Set only on the first start of a forked session; ignored without a resume id. */
+  forkSession?: boolean;
   env?: Record<string, string>;
 }
 
diff --git a/server/src/sessions/SessionManager.ts b/server/src/sessions/SessionManager.ts
index 2074e8d..1051f5f 100644
--- a/server/src/sessions/SessionManager.ts
+++ b/server/src/sessions/SessionManager.ts
@@ -91,6 +91,39 @@ export class SessionManager {
     return dto;
   }
 
+  /**
+   * Fork a session: a new session that inherits the parent's config and full
+   * event log, and resumes the parent's engine transcript on its first turn
+   * under a new engine session id (via the adapter's --fork-session), leaving
+   * the parent untouched.
+   */
+  fork(parentId: string): SessionDto {
+    const parent = this.sessions.get(parentId);
+    if (!parent) throw new HubError('not_found', 'Session not found');
+    if (!parent.engineSessionId) {
+      throw new HubError('cannot_fork', 'Session has no transcript to fork yet (it has not run).');
+    }
+    const engine = this.engines.descriptor(parent.engineId);
+    if (!engine) throw new HubError('unknown_engine', `Unknown engine: ${parent.engineId}`);
+    if (!engine.available) {
+      throw new HubError('engine_unavailable', engine.unavailableReason ?? 'Engine unavailable');
+    }
+    const dto = this.sessions.createForked({
+      id: randomUUID(),
+      title: `${parent.title} (fork)`,
+      engineId: parent.engineId,
+      cwd: parent.cwd,
+      permissionMode: parent.permissionMode,
+      model: parent.requestedModel,
+      settings: parent.settings,
+      engineSessionId: parent.engineSessionId,
+      parentSessionId: parent.id,
+    });
+    this.events.copyEvents(parent.id, dto.id);
+    this.bus.emit('session_upsert', dto);
+    return dto;
+  }
+
   get(id: string): SessionDto | undefined {
     return this.sessions.get(id);
   }
diff --git a/server/src/sessions/SessionRuntime.ts b/server/src/sessions/SessionRuntime.ts
index 3f3ab34..5aedf14 100644
--- a/server/src/sessions/SessionRuntime.ts
+++ b/server/src/sessions/SessionRuntime.ts
@@ -73,6 +73,7 @@ export class SessionRuntime {
       model: this.session.requestedModel,
       settings: this.session.settings,
       resumeEngineSessionId: this.session.engineSessionId ?? undefined,
+      forkSession: this.sessions.forkPending(this.session.id),
     });
     this.run = run;
     if (run.pid) this.sessions.setPid(this.session.id, run.pid);
@@ -113,6 +114,9 @@ export class SessionRuntime {
           // per resume, and only the latest one resumes correctly.
           this.sessions.setEngineSessionId(this.session.id, e.engineSessionId);
           this.session.engineSessionId = e.engineSessionId;
+          // A forked session has now resumed+forked into its own engine session;
+          // consume the one-shot flag so later resumes don't re-fork.
+          this.sessions.clearForkPending(this.session.id);
         }
         if (e.model) this.sessions.setMeta(this.session.id, { model: e.model });
         this.persist(e);
diff --git a/server/test/claude-live.test.ts b/server/test/claude-live.test.ts
index 5b59736..cc391fc 100644
--- a/server/test/claude-live.test.ts
+++ b/server/test/claude-live.test.ts
@@ -79,4 +79,50 @@ live('ClaudeCodeAdapter (live CLI)', () => {
 
     expect(texts.join(' ')).toContain('hub-live-test');
   }, 180_000);
+
+  it('fork-session resumes the parent transcript under a NEW engine session id', async () => {
+    // Parent turn: plant a codeword the model must recall later.
+    const run = adapter.start({
+      sessionId: 'live-fork-parent',
+      cwd: workspace,
+      permissionMode: 'bypassPermissions',
+    });
+    let parentSid: string | undefined;
+    const done1 = new Promise<void>((resolve) => {
+      run.onEvent((e) => {
+        if (e.type === 'engine_meta' && e.engineSessionId) parentSid = e.engineSessionId;
+        if (e.type === 'done') resolve();
+      });
+    });
+    run.sendUserMessage('Remember this secret codeword: BANANA-42. Reply with just "ok".');
+    await done1;
+    run.dispose();
+    await new Promise((r) => setTimeout(r, 500));
+    expect(parentSid).toBeTruthy();
+
+    // Fork: resume the parent transcript, but --fork-session writes into a NEW id.
+    const fork = adapter.start({
+      sessionId: 'live-fork-child',
+      cwd: workspace,
+      permissionMode: 'bypassPermissions',
+      resumeEngineSessionId: parentSid,
+      forkSession: true,
+    });
+    const forkTexts: string[] = [];
+    let forkSid: string | undefined;
+    const done2 = new Promise<void>((resolve) => {
+      fork.onEvent((e) => {
+        if (e.type === 'engine_meta' && e.engineSessionId) forkSid = e.engineSessionId;
+        if (e.type === 'message' && e.role === 'assistant') forkTexts.push(e.text);
+        if (e.type === 'done') resolve();
+      });
+    });
+    fork.sendUserMessage('What was the secret codeword I told you? Reply with just the codeword.');
+    await done2;
+    fork.dispose();
+
+    expect(forkSid).toBeTruthy();
+    expect(forkSid).not.toBe(parentSid); // forked into its own engine session
+    expect(forkTexts.join(' ')).toContain('BANANA-42'); // parent transcript carried over
+  }, 180_000);
 });
diff --git a/server/test/e2e.test.ts b/server/test/e2e.test.ts
index 0d7ec13..365223b 100644
--- a/server/test/e2e.test.ts
+++ b/server/test/e2e.test.ts
@@ -387,4 +387,118 @@ describe('end-to-end with echo engine', () => {
     c.close();
     await server.close();
   }, 15_000);
+
+  it('forks a session: copies its events, runs its own turn, leaves the parent intact', async () => {
+    server = await buildServer(testConfig(dataDir, workspace));
+    const port = server.address.port;
+    const c = new Client(port);
+    await c.open();
+    c.send({ type: 'auth', token: TOKEN });
+    await c.next((m) => m.type === 'auth_ok');
+
+    // A session that has never run has no transcript to fork.
+    const fresh = await api<SessionDto>(port, 'POST', '/api/sessions', {
+      engineId: 'echo',
+      cwd: workspace,
+      permissionMode: 'bypassPermissions',
+    });
+    await expect(api(port, 'POST', `/api/sessions/${fresh.id}/fork`)).rejects.toThrow(/400/);
+
+    // Run one turn so it has an engine transcript.
+    c.send({ type: 'subscribe', sessionId: fresh.id });
+    c.send({ type: 'user_message', sessionId: fresh.id, text: 'parent turn' });
+    await c.next(
+      (m) => m.type === 'event' && m.sessionId === fresh.id && m.event.type === 'done',
+      10_000,
+    );
+    const parent = await api<SessionDto>(port, 'GET', `/api/sessions/${fresh.id}`);
+    expect(parent.engineSessionId).toBeTruthy();
+    const parentTimeline = c.events(parent.id);
+
+    // Fork it: lineage + seeded engine session id + resumable-but-not-live.
+    const forkDto = await api<SessionDto>(port, 'POST', `/api/sessions/${parent.id}/fork`);
+    expect(forkDto.parentId).toBe(parent.id);
+    expect(forkDto.engineSessionId).toBe(parent.engineSessionId);
+    expect(forkDto.engineState).toBe('hibernated');
+
+    // The fork opens with the parent's copied scrollback.
+    const cf = new Client(port);
+    await cf.open();
+    cf.send({ type: 'auth', token: TOKEN });
+    await cf.next((m) => m.type === 'auth_ok');
+    cf.send({ type: 'subscribe', sessionId: forkDto.id, afterEventId: 0 });
+    await cf.next(
+      (m) => m.type === 'event' && m.sessionId === forkDto.id && m.event.type === 'done',
+      10_000,
+    );
+    const forkReplay = cf.events(forkDto.id);
+    expect(forkReplay.map((e) => e.event.type)).toEqual(parentTimeline.map((e) => e.event.type));
+
+    // Running a turn in the fork appends only to the fork; the parent is untouched.
+    cf.send({ type: 'user_message', sessionId: forkDto.id, text: 'fork turn' });
+    await cf.next(
+      (m) =>
+        m.type === 'event' &&
+        m.sessionId === forkDto.id &&
+        m.event.type === 'done' &&
+        m.eventId > forkReplay[forkReplay.length - 1]!.id,
+      10_000,
+    );
+    const parentAfter = await api<SessionEvent[]>(port, 'GET', `/api/sessions/${parent.id}/events`);
+    expect(parentAfter).toHaveLength(parentTimeline.length);
+
+    cf.close();
+    c.close();
+    await server.close();
+  }, 20_000);
+
+  it('bounded initial replay returns the recent window and pages older events over REST', async () => {
+    server = await buildServer(testConfig(dataDir, workspace));
+    const port = server.address.port;
+    const c = new Client(port);
+    await c.open();
+    c.send({ type: 'auth', token: TOKEN });
+    await c.next((m) => m.type === 'auth_ok');
+
+    const session = await api<SessionDto>(port, 'POST', '/api/sessions', {
+      engineId: 'echo',
+      cwd: workspace,
+      permissionMode: 'bypassPermissions',
+    });
+    c.send({ type: 'subscribe', sessionId: session.id });
+    c.send({ type: 'user_message', sessionId: session.id, text: 'one turn' });
+    await c.next(
+      (m) => m.type === 'event' && m.sessionId === session.id && m.event.type === 'done',
+      10_000,
+    );
+
+    const all = await api<SessionEvent[]>(port, 'GET', `/api/sessions/${session.id}/events`);
+    expect(all.length).toBeGreaterThan(3);
+
+    // A fresh subscribe with a small limit replays only the most recent window.
+    const c2 = new Client(port);
+    await c2.open();
+    c2.send({ type: 'auth', token: TOKEN });
+    await c2.next((m) => m.type === 'auth_ok');
+    c2.send({ type: 'subscribe', sessionId: session.id, limit: 3 });
+    const meta = (await c2.next(
+      (m) => m.type === 'replay_meta' && m.sessionId === session.id,
+    )) as Extract<ServerMsg, { type: 'replay_meta' }>;
+    const replayed = c2.events(session.id);
+    expect(replayed.map((e) => e.id)).toEqual(all.slice(-3).map((e) => e.id));
+    expect(meta.hasMoreBefore).toBe(true);
+    expect(meta.oldestEventId).toBe(all[all.length - 3]!.id);
+
+    // The older events page in backward over REST.
+    const earlier = await api<SessionEvent[]>(
+      port,
+      'GET',
+      `/api/sessions/${session.id}/events?beforeId=${meta.oldestEventId}&limit=100`,
+    );
+    expect(earlier.map((e) => e.id)).toEqual(all.slice(0, all.length - 3).map((e) => e.id));
+
+    c2.close();
+    c.close();
+    await server.close();
+  }, 15_000);
 });
diff --git a/shared/src/api.ts b/shared/src/api.ts
index cb901a0..1cd3aaa 100644
--- a/shared/src/api.ts
+++ b/shared/src/api.ts
@@ -37,6 +37,8 @@ export interface SessionDto {
   requestedModel: string | null;
   /** Optional --settings override (file path or inline JSON); null = inherit. */
   settings: string | null;
+  /** If this session was forked from another, the parent's id (else null). */
+  parentId: string | null;
 }
 
 export interface CreateSessionRequest {
diff --git a/shared/src/events.ts b/shared/src/events.ts
index efff672..1a60111 100644
--- a/shared/src/events.ts
+++ b/shared/src/events.ts
@@ -73,6 +73,9 @@ export type NormalizedEvent =
       requestId: string;
       toolName: string;
       input: unknown;
+      /** Engine-suggested permission updates (e.g. allow-rules the CLI proposes).
+       *  Loosely typed since the CLI shape isn't pinned; surfaced as context only. */
+      permissionSuggestions?: unknown;
     }
   | {
       type: 'approval_resolved';
diff --git a/shared/src/protocol.ts b/shared/src/protocol.ts
index 6f59a6f..e74d315 100644
--- a/shared/src/protocol.ts
+++ b/shared/src/protocol.ts
@@ -9,7 +9,9 @@ import type { SessionDto } from './api.js';
 
 export type ClientMsg =
   | { type: 'auth'; token: string }
-  | { type: 'subscribe'; sessionId: string; afterEventId?: number }
+  /** afterEventId set = forward catch-up (full). Omitted = bounded initial load
+   *  of the most recent `limit` events (server-clamped). */
+  | { type: 'subscribe'; sessionId: string; afterEventId?: number; limit?: number }
   | { type: 'unsubscribe'; sessionId: string }
   | { type: 'user_message'; sessionId: string; text: string }
   | {
@@ -36,6 +38,14 @@ export type ServerMsg =
       delta: string;
     }
   | { type: 'status'; sessionId: string; status: SessionStatus }
+  /** Sent once after a bounded initial replay: whether older events exist and
+   *  the oldest event id currently sent (the cursor for "load earlier"). */
+  | {
+      type: 'replay_meta';
+      sessionId: string;
+      hasMoreBefore: boolean;
+      oldestEventId: number | null;
+    }
   | { type: 'session_upsert'; session: SessionDto }
   | { type: 'session_deleted'; sessionId: string }
   | { type: 'error'; sessionId?: string; code: string; message: string };
diff --git a/web/src/components/ApprovalCard.svelte b/web/src/components/ApprovalCard.svelte
index 01c6d72..632eff3 100644
--- a/web/src/components/ApprovalCard.svelte
+++ b/web/src/components/ApprovalCard.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
   import type { TimelineItem } from '../lib/timeline.js';
   import { sendApproval } from '../lib/ws.js';
-  import { summarizeInput } from '../lib/format.js';
+  import { permissionSuggestionLabels, summarizeInput } from '../lib/format.js';
 
   let {
     sessionId,
@@ -21,6 +21,8 @@
     sendApproval(sessionId, approval.requestId, 'deny', denyMessage.trim() || undefined);
   }
 
+  const suggestions = $derived(permissionSuggestionLabels(approval.permissionSuggestions));
+
   const resolvedLabel = $derived.by(() => {
     if (!approval.resolved) return null;
     const { behavior, resolvedBy } = approval.resolved;
@@ -45,6 +47,14 @@
       <span class="summary">{summarizeInput(approval.toolName, approval.input)}</span>
     </div>
     <pre>{JSON.stringify(approval.input, null, 2)}</pre>
+    {#if suggestions.length}
+      <div class="suggestions">
+        <span class="sg-label">CLI suggests</span>
+        {#each suggestions as sg}
+          <span class="chip" title={sg}>{sg}</span>
+        {/each}
+      </div>
+    {/if}
     <div class="actions">
       <button class="primary" disabled={responded} onclick={allow}>Allow</button>
       <button class="danger" disabled={responded} onclick={() => (showDeny = !showDeny)}>Deny…</button>
@@ -111,6 +121,30 @@
     white-space: pre-wrap;
     overflow-wrap: break-word;
   }
+  .suggestions {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    flex-wrap: wrap;
+  }
+  .sg-label {
+    font-size: 10.5px;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    color: var(--text-dim);
+  }
+  .chip {
+    font-family: var(--mono);
+    font-size: 11.5px;
+    background: var(--bg-raised);
+    border: 1px solid var(--border);
+    border-radius: 999px;
+    padding: 2px 8px;
+    max-width: 100%;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
   .actions {
     display: flex;
     gap: 8px;
diff --git a/web/src/components/ChatView.svelte b/web/src/components/ChatView.svelte
index 57072c8..9c63b19 100644
--- a/web/src/components/ChatView.svelte
+++ b/web/src/components/ChatView.svelte
@@ -3,10 +3,11 @@
   import {
     deltasBySession,
     eventsBySession,
+    historyMetaBySession,
     sessions,
     statusBySession,
   } from '../lib/stores.js';
-  import { sendInterrupt, sendUserMessage, subscribeSession } from '../lib/ws.js';
+  import { loadEarlier, sendInterrupt, sendUserMessage, subscribeSession } from '../lib/ws.js';
   import { buildTimeline } from '../lib/timeline.js';
   import StatusBar from './StatusBar.svelte';
   import MessageBubble from './MessageBubble.svelte';
@@ -27,6 +28,25 @@
   const timeline = $derived(buildTimeline(events));
   const streamBuffers = $derived([...($deltasBySession.get(sessionId)?.entries() ?? [])]);
   const busy = $derived(status === 'running' || status === 'awaiting_approval');
+  const historyMeta = $derived($historyMetaBySession.get(sessionId));
+  let loadingEarlier = $state(false);
+
+  async function onLoadEarlier(): Promise<void> {
+    if (!scroller || loadingEarlier) return;
+    loadingEarlier = true;
+    const before = scroller.scrollHeight;
+    const prevTop = scroller.scrollTop;
+    try {
+      await loadEarlier(sessionId);
+      await tick();
+      // Keep the viewport anchored: prepended content grows scrollHeight from the top.
+      if (scroller) scroller.scrollTop = prevTop + (scroller.scrollHeight - before);
+    } catch (e) {
+      showToast(`Load earlier failed: ${(e as Error).message}`);
+    } finally {
+      loadingEarlier = false;
+    }
+  }
 
   $effect(() => {
     subscribeSession(sessionId);
@@ -70,6 +90,12 @@
 
   <div class="scroll" bind:this={scroller} onscroll={onScroll}>
     <div class="timeline">
+      {#if historyMeta?.hasMoreBefore}
+        <button class="load-earlier" onclick={onLoadEarlier} disabled={loadingEarlier}>
+          {loadingEarlier ? 'Loading…' : 'Load earlier messages'}
+        </button>
+      {/if}
+
       {#each timeline as item (item.id)}
         {#if item.kind === 'message'}
           <MessageBubble role={item.role} text={item.text} />
@@ -133,6 +159,15 @@
     flex-direction: column;
     gap: 10px;
   }
+  .load-earlier {
+    align-self: center;
+    padding: 5px 14px;
+    font-size: 12.5px;
+    background: var(--bg-panel);
+    border: 1px solid var(--border);
+    border-radius: 999px;
+    color: var(--text-dim);
+  }
   .streaming {
     position: relative;
     background: var(--bg-panel);
diff --git a/web/src/components/SessionSidebar.svelte b/web/src/components/SessionSidebar.svelte
index a8200fb..0011c09 100644
--- a/web/src/components/SessionSidebar.svelte
+++ b/web/src/components/SessionSidebar.svelte
@@ -1,5 +1,12 @@
 <script lang="ts">
-  import { activeSessionId, connState, sessions, statusBySession, token } from '../lib/stores.js';
+  import {
+    activeSessionId,
+    connState,
+    sessions,
+    statusBySession,
+    token,
+    upsertSession,
+  } from '../lib/stores.js';
   import { api } from '../lib/api.js';
   import { disconnect, subscribeSession } from '../lib/ws.js';
   import { engineStateLabel, isDangerMode, relativeTime } from '../lib/format.js';
@@ -10,12 +17,37 @@
   let showNew = $state(false);
   let renamingId: string | null = $state(null);
   let renameValue = $state('');
+  let showArchived = $state(false);
+  let filterText = $state('');
+  let loadedArchived = false;
+
+  const visibleSessions = $derived(
+    $sessions.filter((s) => {
+      if ((s.archivedAt !== null) !== showArchived) return false;
+      const q = filterText.trim().toLowerCase();
+      return !q || s.title.toLowerCase().includes(q);
+    }),
+  );
 
   function select(id: string): void {
     activeSessionId.set(id);
     subscribeSession(id);
   }
 
+  async function toggleArchived(): Promise<void> {
+    showArchived = !showArchived;
+    // Archived sessions aren't loaded at boot; fetch them once on first reveal.
+    if (showArchived && !loadedArchived) {
+      loadedArchived = true;
+      try {
+        for (const s of await api.sessions(true)) upsertSession(s);
+      } catch (e) {
+        loadedArchived = false;
+        showToast(`Load archived failed: ${(e as Error).message}`);
+      }
+    }
+  }
+
   function statusColor(id: string): string {
     switch ($statusBySession.get(id) ?? $sessions.find((s) => s.id === id)?.status) {
       case 'running':
@@ -49,6 +81,24 @@
     }
   }
 
+  async function fork(id: string): Promise<void> {
+    try {
+      const dto = await api.forkSession(id);
+      upsertSession(dto);
+      select(dto.id);
+    } catch (e) {
+      showToast(`Fork failed: ${(e as Error).message}`);
+    }
+  }
+
+  async function archive(id: string, archived: boolean): Promise<void> {
+    try {
+      await api.archiveSession(id, archived);
+    } catch (e) {
+      showToast(`${archived ? 'Archive' : 'Unarchive'} failed: ${(e as Error).message}`);
+    }
+  }
+
   function logout(): void {
     token.set(null);
     disconnect();
@@ -63,8 +113,18 @@
 
   <button class="primary new" onclick={() => (showNew = true)}>+ New session</button>
 
+  <div class="filters">
+    <input class="search" placeholder="Search sessions…" bind:value={filterText} />
+    <button
+      class="toggle"
+      class:on={showArchived}
+      title={showArchived ? 'Show active sessions' : 'Show archived sessions'}
+      onclick={toggleArchived}>🗄</button
+    >
+  </div>
+
   <nav>
-    {#each $sessions as s (s.id)}
+    {#each visibleSessions as s (s.id)}
       <div
         class="item"
         class:active={s.id === $activeSessionId}
@@ -111,6 +171,23 @@
               renameValue = s.title;
             }}>✎</button
           >
+          <button
+            class="icon"
+            title="Fork session"
+            disabled={!s.engineSessionId}
+            onclick={(e) => {
+              e.stopPropagation();
+              void fork(s.id);
+            }}>⑂</button
+          >
+          <button
+            class="icon"
+            title={s.archivedAt ? 'Unarchive' : 'Archive'}
+            onclick={(e) => {
+              e.stopPropagation();
+              void archive(s.id, !s.archivedAt);
+            }}>{s.archivedAt ? '↩' : '📁'}</button
+          >
           <button
             class="icon"
             title="Delete"
@@ -122,7 +199,7 @@
         </div>
       </div>
     {:else}
-      <p class="none">No sessions yet.</p>
+      <p class="none">{showArchived ? 'No archived sessions.' : 'No sessions yet.'}</p>
     {/each}
   </nav>
 
@@ -171,6 +248,28 @@
   .new {
     margin: 8px 12px;
   }
+  .filters {
+    display: flex;
+    gap: 6px;
+    padding: 0 12px 6px;
+  }
+  .search {
+    flex: 1;
+    min-width: 0;
+    padding: 5px 8px;
+    font-size: 12px;
+  }
+  .toggle {
+    padding: 4px 8px;
+    background: none;
+    border: 1px solid var(--border);
+    border-radius: 6px;
+    font-size: 12px;
+  }
+  .toggle.on {
+    background: var(--bg-raised);
+    border-color: var(--accent);
+  }
   nav {
     flex: 1;
     overflow-y: auto;
@@ -245,6 +344,10 @@
     background: none;
     border: none;
   }
+  .icon:disabled {
+    opacity: 0.3;
+    cursor: default;
+  }
   .none {
     color: var(--text-dim);
     text-align: center;
diff --git a/web/src/lib/api.ts b/web/src/lib/api.ts
index 03c05cf..5acb5cd 100644
--- a/web/src/lib/api.ts
+++ b/web/src/lib/api.ts
@@ -5,6 +5,7 @@ import type {
   FsBrowseResponse,
   FsValidateResponse,
   SessionDto,
+  SessionEvent,
   UpdateSessionRequest,
 } from '@hub/shared';
 import { token } from './stores.js';
@@ -50,9 +51,14 @@ export const api = {
   sessions: (includeArchived = false) =>
     request<SessionDto[]>('GET', `/api/sessions${includeArchived ? '?includeArchived=1' : ''}`),
   createSession: (req: CreateSessionRequest) => request<SessionDto>('POST', '/api/sessions', req),
+  forkSession: (id: string) => request<SessionDto>('POST', `/api/sessions/${id}/fork`),
   updateSession: (id: string, req: UpdateSessionRequest) =>
     request<SessionDto>('PATCH', `/api/sessions/${id}`, req),
+  archiveSession: (id: string, archived = true) =>
+    request<SessionDto>('PATCH', `/api/sessions/${id}`, { archived }),
   deleteSession: (id: string) => request<{ ok: boolean }>('DELETE', `/api/sessions/${id}`),
+  eventsBefore: (id: string, beforeId: number, limit = 500) =>
+    request<SessionEvent[]>('GET', `/api/sessions/${id}/events?beforeId=${beforeId}&limit=${limit}`),
   fsValidate: (path: string) => request<FsValidateResponse>('POST', '/api/fs/validate', { path }),
   fsBrowse: (path?: string) =>
     request<FsBrowseResponse>('GET', `/api/fs/browse${path ? `?path=${encodeURIComponent(path)}` : ''}`),
diff --git a/web/src/lib/format.ts b/web/src/lib/format.ts
index ab8264c..58ebf5c 100644
--- a/web/src/lib/format.ts
+++ b/web/src/lib/format.ts
@@ -62,3 +62,36 @@ export const PERMISSION_MODES: {
 export function isDangerMode(mode: PermissionMode | null): boolean {
   return mode === 'bypassPermissions';
 }
+
+/**
+ * Render the CLI's `permission_suggestions` (unpinned shape) into short display
+ * chips, defensively. Handles the common cases (an array of rule-update objects
+ * with `{ behavior, rules: [{ toolName, ruleContent }] }`, a mode change, plain
+ * strings) and falls back to a compact JSON string for anything unexpected.
+ */
+export function permissionSuggestionLabels(suggestions: unknown): string[] {
+  const out: string[] = [];
+  const clip = (s: string): string => (s.length > 80 ? s.slice(0, 77) + '…' : s);
+  const arr = Array.isArray(suggestions) ? suggestions : suggestions == null ? [] : [suggestions];
+  for (const item of arr) {
+    if (item && typeof item === 'object') {
+      const o = item as Record<string, unknown>;
+      if (Array.isArray(o.rules)) {
+        const behavior = typeof o.behavior === 'string' ? o.behavior : 'allow';
+        for (const r of o.rules) {
+          const ro = (r ?? {}) as Record<string, unknown>;
+          const tool = typeof ro.toolName === 'string' ? ro.toolName : 'tool';
+          const content = typeof ro.ruleContent === 'string' ? ro.ruleContent : '';
+          out.push(clip(`${behavior} ${tool}${content ? `(${content})` : ''}`));
+        }
+        continue;
+      }
+      if (typeof o.mode === 'string') {
+        out.push(clip(`mode: ${o.mode}`));
+        continue;
+      }
+    }
+    out.push(clip(typeof item === 'string' ? item : JSON.stringify(item)));
+  }
+  return out.filter(Boolean);
+}
diff --git a/web/src/lib/stores.ts b/web/src/lib/stores.ts
index 756a8a5..f96006e 100644
--- a/web/src/lib/stores.ts
+++ b/web/src/lib/stores.ts
@@ -18,6 +18,10 @@ export const eventsBySession = writable<Map<string, SessionEvent[]>>(new Map());
 /** In-flight streaming text buffers per session, keyed by messageKey. */
 export const deltasBySession = writable<Map<string, Map<string, string>>>(new Map());
 export const statusBySession = writable<Map<string, SessionStatus>>(new Map());
+/** Back-paging state per session: whether older events exist + the oldest loaded id. */
+export const historyMetaBySession = writable<
+  Map<string, { hasMoreBefore: boolean; oldestEventId: number | null }>
+>(new Map());
 
 /** Highest event id seen per session — the replay cursor for (re)subscribes. */
 export const lastEventId = new Map<string, number>();
@@ -64,6 +68,29 @@ export function appendEvent(e: SessionEvent): void {
   }
 }
 
+export function setHistoryMeta(
+  sessionId: string,
+  meta: { hasMoreBefore: boolean; oldestEventId: number | null },
+): void {
+  historyMetaBySession.update((m) => {
+    m.set(sessionId, meta);
+    return new Map(m);
+  });
+}
+
+/** Prepend older events fetched via REST (ids below the current window). Does not
+ *  touch the forward replay cursor (lastEventId), which tracks the newest id. */
+export function prependEvents(sessionId: string, older: SessionEvent[]): void {
+  if (!older.length) return;
+  eventsBySession.update((m) => {
+    const list = m.get(sessionId) ?? [];
+    const seen = new Set(list.map((e) => e.id));
+    const merged = [...older.filter((e) => !seen.has(e.id)), ...list].sort((a, b) => a.id - b.id);
+    m.set(sessionId, merged);
+    return new Map(m);
+  });
+}
+
 export function appendDelta(sessionId: string, messageKey: string, delta: string): void {
   deltasBySession.update((m) => {
     const buffers = m.get(sessionId) ?? new Map<string, string>();
diff --git a/web/src/lib/timeline.ts b/web/src/lib/timeline.ts
index 5aec175..0b38dfb 100644
--- a/web/src/lib/timeline.ts
+++ b/web/src/lib/timeline.ts
@@ -25,6 +25,7 @@ export type TimelineItem =
       requestId: string;
       toolName: string;
       input: unknown;
+      permissionSuggestions?: unknown;
       resolved?: { behavior: 'allow' | 'deny'; resolvedBy: 'user' | 'policy' | 'stale' };
     }
   | {
@@ -89,6 +90,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           requestId: e.requestId,
           toolName: e.toolName,
           input: e.input,
+          permissionSuggestions: e.permissionSuggestions,
         };
         approvalByRequestId.set(e.requestId, item);
         items.push(item);
diff --git a/web/src/lib/ws.ts b/web/src/lib/ws.ts
index cafb007..7175bcc 100644
--- a/web/src/lib/ws.ts
+++ b/web/src/lib/ws.ts
@@ -1,17 +1,24 @@
 import { get } from 'svelte/store';
 import type { ClientMsg, ServerMsg } from '@hub/shared';
+import { api } from './api.js';
 import {
   appendDelta,
   appendEvent,
   connState,
+  historyMetaBySession,
   lastEventId,
+  prependEvents,
   removeSession,
+  setHistoryMeta,
   setStatus,
   subscribed,
   token,
   upsertSession,
 } from './stores.js';
 
+/** Events requested on a bounded initial subscribe / each "load earlier" page. */
+const REPLAY_LIMIT = 500;
+
 /**
  * Reconnecting WebSocket client: auth by first message, resubscribe to every
  * known session with its replay cursor after each (re)connect.
@@ -61,6 +68,12 @@ export function connect(): void {
       case 'status':
         setStatus(msg.sessionId, msg.status);
         return;
+      case 'replay_meta':
+        setHistoryMeta(msg.sessionId, {
+          hasMoreBefore: msg.hasMoreBefore,
+          oldestEventId: msg.oldestEventId,
+        });
+        return;
       case 'session_upsert':
         upsertSession(msg.session);
         return;
@@ -99,7 +112,22 @@ function send(msg: ClientMsg): void {
 export function subscribeSession(sessionId: string): void {
   if (subscribed.has(sessionId)) return;
   subscribed.add(sessionId);
-  send({ type: 'subscribe', sessionId, afterEventId: lastEventId.get(sessionId) ?? 0 });
+  const cur = lastEventId.get(sessionId);
+  // A known cursor => forward catch-up; first open => bounded initial window.
+  if (cur !== undefined) send({ type: 'subscribe', sessionId, afterEventId: cur });
+  else send({ type: 'subscribe', sessionId, limit: REPLAY_LIMIT });
+}
+
+/** Page one window of older events (before the oldest loaded id) into the store. */
+export async function loadEarlier(sessionId: string): Promise<void> {
+  const meta = get(historyMetaBySession).get(sessionId);
+  if (!meta?.hasMoreBefore || meta.oldestEventId == null) return;
+  const older = await api.eventsBefore(sessionId, meta.oldestEventId, REPLAY_LIMIT);
+  prependEvents(sessionId, older);
+  setHistoryMeta(sessionId, {
+    hasMoreBefore: older.length === REPLAY_LIMIT,
+    oldestEventId: older.length ? older[0]!.id : meta.oldestEventId,
+  });
 }
 
 export function sendUserMessage(sessionId: string, text: string): void {

From 86377456e0bdf5ca9534939ef535ee7b123b0abf Mon Sep 17 00:00:00 2001
From: "Wit, Floris De (178)" <floris_de.wit@mercedes-benz.com>
Date: Thu, 9 Jul 2026 16:17:23 +0200
Subject: [PATCH 2/5] docs: architecture notes for
 fork/archive/approvals/pagination; add handoff3

---
 CLAUDE.md   |  7 +++++--
 handoff3.md | 42 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 47 insertions(+), 2 deletions(-)
 create mode 100644 handoff3.md

diff --git a/CLAUDE.md b/CLAUDE.md
index 4d541cc..8b6ee99 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -55,6 +55,7 @@ The spine is: **engine adapter normalizes a CLI stream into `NormalizedEvent`s -
 - **`SessionRuntime`** (`server/src/sessions/SessionRuntime.ts`) is the per-session state machine: `idle -> running <-> awaiting_approval -> idle | error`, one in-flight turn at a time. It lazily starts the engine on the first message (`ensureRun`), relays each engine-surfaced `approval_request` to the user (policy lives in the engine, not the hub), persists every complete event, and arms an idle timer that disposes the engine while leaving the session resumable. A `user_message` while `busy` is **queued** (bounded at `MAX_QUEUE`) and drained one turn at a time on each `done`; interrupt/stop/dispose clear the queue.
 - **Two state axes** (both on `SessionDto`): interaction `status` (idle/running/awaiting_approval/error) and engine liveness `engineState` (`new` -> `live` on spawn -> `hibernated` on idle-dispose/stop/boot-reconcile, or `dead` on an unexpected exit) plus `enginePid`. `stopEngine()` (WS `stop_engine`) tears the process down now while keeping the session resumable; a crash mid-turn also closes the open turn with a `done{error}`.
 - **Resume**: `engine_session_id` is updated from *every* engine `init` (`engine_meta`), not just the first, because some CLI versions mint a new session id per resume and only the latest resumes correctly. The hibernated/dead engine is respawned with `--resume <engineSessionId>` on the next message.
+- **Fork** (`POST /api/sessions/:id/fork` -> `SessionManager.fork`): copies the parent's config + event log (`EventsRepo.copyEvents`) into a new session that seeds the parent's `engine_session_id` and sets a one-shot `fork_pending` flag (migration 4). On the fork's first `ensureRun` that flag adds `--fork-session` alongside `--resume <parent>`, so the CLI replays the parent transcript but writes into a *new* engine session id; `fork_pending` is consumed on the first `engine_meta`. The parent is untouched. Only a session that has run (non-null `engineSessionId`) is forkable.
 
 ### Permission control (the "safety dial")
 
@@ -62,6 +63,8 @@ A hub session behaves like a native `claude` session started in the same directo
 
 Permission policy is **delegated to the engine**, not decided by the hub. The Claude CLI applies `--permission-mode` natively and only routes tools it wants asked to `--permission-prompt-tool stdio`; the hub relays every surfaced `approval_request` to the user. There is no hub-side tool-name policy anymore (the old `READ_ONLY_TOOLS` set and its spoofing sharp edge are gone). Consequence, and intended for CLI parity: host `PreToolUse` hooks / `permissions.allow` rules can auto-allow tools so the hub never sees them. The echo stub emulates a mode itself via `permissionModeDisposition` (ask/allow/deny) to stay a faithful template.
 
+The CLI's `permission_suggestions` (allow-rules it proposes for a prompt) ride through on `approval_request.permissionSuggestions` (loosely typed; shape not pinned) and render as **informational** chips in the ApprovalCard. The hub does not persist rules from them (that would mutate `~/.claude`); allow/deny is unchanged.
+
 ### Engine adapters
 
 `server/src/engines/types.ts` defines the `EngineAdapter` / `EngineRun` contract. An adapter emits `approval_request` only for tools its permission mode wants asked, and blocks the tool until `respondToApproval()` is called; the hub relays it to the user (auto-allow/deny is the engine's job, not the hub's).
@@ -73,12 +76,12 @@ Permission policy is **delegated to the engine**, not decided by the hub. The Cl
 
 ### Persistence
 
-`server/src/db/database.ts` opens SQLite (WAL, foreign keys on) with embedded, id-ordered migrations (no external `.sql` files, so `dist` is self-contained). Two tables: `sessions` and `events` (events cascade-delete with their session). Event `id` is the replay cursor. `EventsRepo`/`SessionsRepo` in `db/repos.ts` are the only DB access; keep SQL there. There is no pagination on event replay yet (long sessions replay fully).
+`server/src/db/database.ts` opens SQLite (WAL, foreign keys on) with embedded, id-ordered migrations (no external `.sql` files, so `dist` is self-contained). Two tables: `sessions` and `events` (events cascade-delete with their session). Event `id` is the replay cursor. `EventsRepo`/`SessionsRepo` in `db/repos.ts` are the only DB access; keep SQL there. Event replay is windowed: a fresh subscribe replays the most recent N events (`listRecent`) and older history pages backward on demand (`listBefore`, keyset on the `(session_id, id)` index); forward catch-up (`listAfter`) is unchanged.
 
 ### Transport
 
 - **REST** (`server/src/api/routes.ts`): sessions CRUD, `/api/engines`, `/api/fs/{validate,browse}`, `/api/health`. Bearer-token auth via an `onRequest` hook (`health` exempt). `HubError` maps to status codes (`not_found` -> 404, `session_busy` -> 409, else 400).
-- **WebSocket** (`server/src/api/ws.ts`, protocol in `shared/src/protocol.ts`): one socket per tab at `/ws`, all sessions multiplexed. **Auth is by first message, never a URL token** (keeps it out of access logs). After auth, `subscribe {sessionId, afterEventId}` replays persisted history from the cursor (synchronous better-sqlite3 read, so no live event interleaves), then marks the subscription live. The web client (`web/src/lib/ws.ts`) reconnects with backoff and re-subscribes every known session from its last-seen event id.
+- **WebSocket** (`server/src/api/ws.ts`, protocol in `shared/src/protocol.ts`): one socket per tab at `/ws`, all sessions multiplexed. **Auth is by first message, never a URL token** (keeps it out of access logs). After auth, `subscribe {sessionId, afterEventId?, limit?}` replays persisted history (synchronous better-sqlite3 read, so no live event interleaves), then marks the subscription live. With `afterEventId` it is forward catch-up (full); omitted, it is a bounded initial load of the most recent `limit` events followed by a `replay_meta {hasMoreBefore, oldestEventId}` frame the client uses to page older history over REST (`/api/sessions/:id/events?beforeId&limit`). The web client (`web/src/lib/ws.ts`) reconnects with backoff and re-subscribes every known session from its last-seen event id.
 
 ### Working-directory safety
 
diff --git a/handoff3.md b/handoff3.md
new file mode 100644
index 0000000..6116c29
--- /dev/null
+++ b/handoff3.md
@@ -0,0 +1,42 @@
+# Handoff #3 — Session-management completeness (fork, archive, approvals, pagination)
+
+**Branch:** `claude/session-mgmt-completeness` · **Status:** built, typechecked, and verified end-to-end (21 keyless tests + a live claude-code fork/resume drive). Continues the `handoff2.md` next-steps. No new engine, no scheduling: this rounds out the session lifecycle so a hub session is a fully manageable "terminal window" (README §6 req #4: list / resume / **fork** / **archive** / **search**).
+
+## What changed
+
+One additive DB migration (id:4: `parent_session_id`, `fork_pending`); the other three workstreams ride in existing columns / JSON payloads.
+
+1. **Session fork (`--fork-session`)** — `POST /api/sessions/:id/fork` (`SessionManager.fork`) copies the parent's config + event log (`EventsRepo.copyEvents`) into a new session that seeds the parent's `engine_session_id` and sets a one-shot `fork_pending` flag. On the fork's first turn that flag adds `--fork-session` alongside `--resume <parent>`, so the CLI replays the parent transcript but writes into a *new* engine session id (consumed on the first `engine_meta`). The parent is untouched; only a session that has run is forkable. `SessionDto.parentId` records lineage. UI: a fork button in the sidebar row.
+2. **Archived-sessions view** — backend already supported archive end-to-end, so this is UI wiring: a "Show archived" toggle (lazy `api.sessions(true)`), an archive/unarchive row action, a render-time `archivedAt` filter, plus a title **search** filter.
+3. **Approval affordances** — the CLI's `permission_suggestions` now ride on `approval_request.permissionSuggestions` and render as **informational** chips in the ApprovalCard (defensive rendering; loosely typed). The hub deliberately does *not* persist allow-rules from them (that would mutate `~/.claude`); allow/deny is unchanged.
+4. **Replay pagination** — a fresh subscribe replays the most recent N events (`listRecent`, default 500) and sends a `replay_meta {hasMoreBefore, oldestEventId}` frame; older history pages backward over REST (`/api/sessions/:id/events?beforeId&limit` -> `listBefore`, keyset on the `(session_id, id)` index). Forward catch-up on reconnect (`afterEventId`) is unchanged, preserving the atomic replay-then-live invariant. UI: a "Load earlier" control with scroll anchoring.
+
+## How it was verified
+
+- `pnpm build` / `pnpm typecheck` / `pnpm test` green: **21 keyless** passing (echo engine), web bundle unchanged at 233 KB (79 KB gzip), svelte-check 0 errors.
+- New keyless e2e: fork copies the parent's events, runs its own turn, and leaves the parent's log untouched; bounded initial replay returns only the recent window with `hasMoreBefore`, and older events page in over REST.
+- Migration 4 applied cleanly to the real dev DB (11 existing sessions backfilled `parent_session_id=null`, `fork_pending=0`).
+- **Live** (gated, `CLAUDE_LIVE=1`): forking a real Claude session minted a *new* engine session id and recalled the parent's planted codeword, confirming `--fork-session` carried the transcript while the parent id stayed intact.
+
+## Run & test locally
+
+See `handoff2.md` for the full toolchain note (corepack/pnpm). Servers already run on :3000 / :5173, login token from the server log.
+
+```bash
+pnpm --filter @hub/shared build   # server/web import shared's dist — build it first
+pnpm build && pnpm typecheck && pnpm test        # 21 keyless tests
+CLAUDE_LIVE=1 pnpm --filter @hub/server test     # live claude drives (~cents)
+```
+
+What to exercise on this branch:
+- **Fork**: run a turn in a session, then click the fork button (⑂). The new session opens with the prior scrollback and continues the same conversation on its own branch; the parent is unchanged. (Disabled until the session has run once.)
+- **Archive / search**: archive a session (📁), toggle **🗄 Show archived** to see it, unarchive (↩). Type in the search box to filter by title.
+- **Approval affordances**: in a `manual`-mode session, when a tool needs approval the card shows "CLI suggests" chips for context.
+- **Pagination**: in a session with a long history, only the recent window loads; click **Load earlier** to page older messages in.
+
+## Not done / next
+
+- **Persist an allow-rule from a suggestion chip** (click-to-allow-always) — deliberately out of scope; needs extra protocol/CLI surface and writes to `~/.claude`.
+- **Roadmap** (still open from handoff2): Copilot CLI / Codex adapters (Codex is installed locally and feasible via `codex exec --json` + sandbox modes; a differently-shaped adapter that stress-tests the contract), scheduling/automation.
+- Fork lineage is stored (`parentId`) but not yet surfaced in the UI (e.g. a "forked from" hint).
+- Pagination back-paging uses a full-page heuristic for `hasMoreBefore`; a final partial page can leave one no-op "Load earlier" click.

From 646de21b23f8a081ff5182cb5031b25607e7aaf0 Mon Sep 17 00:00:00 2001
From: "Wit, Floris De (178)" <floris_de.wit@mercedes-benz.com>
Date: Thu, 9 Jul 2026 16:58:31 +0200
Subject: [PATCH 3/5] feat(web): New Session home launcher with git branch +
 isolated worktree + initial task
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replaces the utilitarian New Session modal with a home launcher screen (shown in
the main pane when no session is active), taking OpenHands' launcher as a base and
pushing further with our local filesystem/git access.

Launcher (web/src/components/Launcher.svelte, replaces NewSessionDialog):
- Recent projects (derived from prior sessions' cwds, worktree sessions excluded),
  project directory picker with browse + live validate + git badge.
- Git: shows the repo's current branch; an "Isolate in a new worktree" toggle that,
  when on, reveals a searchable base-branch input (datalist).
- Optional initial-task box that launches the agent immediately (Enter launches,
  Shift+Enter newline).
- Engine / permission-mode / model / settings collapsed into Advanced; the engine
  picker is hidden when only one engine is available.
- App renders it in the empty pane; the sidebar "+ New session" clears the active
  session to reveal it (modal retired).

Git backend (new):
- server/src/fs/git.ts: gitInfo (branches/current/default), addWorktree (new hub/…
  branch, never checks out over the user's tree), removeWorktree (+ prunes the
  hub/ branch). GET /api/git/info?cwd=. WORKTREE_ROOT config (default
  $DATA_DIR/worktrees).

Session create/delete (server):
- CreateSessionRequest gains branch/worktree/initialPrompt; SessionDto.worktreePath
  (migration 5). On create with worktree, the session runs in a hub-managed worktree
  as its cwd (trusted); with initialPrompt the first turn auto-runs. Delete cleans up
  the worktree.

Tests: +git.test.ts (gitInfo/addWorktree/removeWorktree) and +e2e worktree/initial-
prompt test (25 keyless passing). README documents WORKTREE_ROOT.
---
 README.md                                  |   1 +
 server/src/api/routes.ts                   |  10 +
 server/src/config.ts                       |   6 +-
 server/src/db/database.ts                  |   8 +
 server/src/db/repos.ts                     |  20 +-
 server/src/fs/git.ts                       |  90 ++++
 server/src/sessions/SessionManager.ts      |  49 ++-
 server/test/e2e.test.ts                    |  61 ++-
 server/test/git.test.ts                    |  57 +++
 shared/src/api.ts                          |  15 +
 web/src/App.svelte                         |  22 +-
 web/src/components/Launcher.svelte         | 469 +++++++++++++++++++++
 web/src/components/NewSessionDialog.svelte | 308 --------------
 web/src/components/SessionSidebar.svelte   |  14 +-
 web/src/lib/api.ts                         |   3 +
 15 files changed, 784 insertions(+), 349 deletions(-)
 create mode 100644 server/src/fs/git.ts
 create mode 100644 server/test/git.test.ts
 create mode 100644 web/src/components/Launcher.svelte
 delete mode 100644 web/src/components/NewSessionDialog.svelte

diff --git a/README.md b/README.md
index a953990..d8e91bd 100644
--- a/README.md
+++ b/README.md
@@ -150,6 +150,7 @@ See the install steps in [`deploy/agentic-cli-hub.service`](deploy/agentic-cli-h
 | `HOST` / `PORT` | `127.0.0.1` / `3000` | Bind address |
 | `DATA_DIR` | `./data` | SQLite session history |
 | `WORKSPACE_ROOTS` | `$HOME` | Colon-separated dirs sessions may target as cwd |
+| `WORKTREE_ROOT` | `$DATA_DIR/worktrees` | Where isolated per-session git worktrees are created |
 | `ENGINES` | `claude-code,echo` | Engine adapters to enable |
 | `CLAUDE_BIN` | `claude` on PATH | Engine binary override |
 | `ENGINE_IDLE_TIMEOUT_MS` | `1800000` | Kill idle engine processes (sessions resume seamlessly) |
diff --git a/server/src/api/routes.ts b/server/src/api/routes.ts
index 2c8f662..f201840 100644
--- a/server/src/api/routes.ts
+++ b/server/src/api/routes.ts
@@ -9,6 +9,7 @@ import type { HubConfig } from '../config.js';
 import type { EventsRepo } from '../db/repos.js';
 import type { EngineRegistry } from '../engines/registry.js';
 import { browse, validateCwd } from '../fs/workspace.js';
+import { gitInfo } from '../fs/git.js';
 import type { SessionManager } from '../sessions/SessionManager.js';
 import { HubError } from '../sessions/SessionRuntime.js';
 
@@ -115,4 +116,13 @@ export function registerRoutes(app: FastifyInstance, deps: RouteDeps): void {
       return reply.code(400).send({ error: 'bad_request', message: (err as Error).message });
     }
   });
+
+  app.get('/api/git/info', async (req, reply) => {
+    const q = req.query as { cwd?: string };
+    const check = validateCwd(config.workspaceRoots, q.cwd ?? '');
+    if (!check.ok || !check.resolved) {
+      return reply.code(400).send({ error: 'invalid_cwd', message: check.error ?? 'invalid path' });
+    }
+    return gitInfo(check.resolved);
+  });
 }
diff --git a/server/src/config.ts b/server/src/config.ts
index f6531fb..32d4ad8 100644
--- a/server/src/config.ts
+++ b/server/src/config.ts
@@ -11,6 +11,8 @@ export interface HubConfig {
   dataDir: string;
   /** Directories sessions are allowed to target as cwd. */
   workspaceRoots: string[];
+  /** Hub-owned root for isolated per-session git worktrees. */
+  worktreeRoot: string;
   /** Engine ids to enable, in order. */
   engines: string[];
   claudeBin: string | undefined;
@@ -30,14 +32,16 @@ export function loadConfig(env: NodeJS.ProcessEnv = process.env): HubConfig {
     .map((p) => p.trim())
     .filter(Boolean)
     .map((p) => path.resolve(p));
+  const dataDir = path.resolve(env.DATA_DIR ?? './data');
 
   return {
     host: env.HOST ?? '127.0.0.1',
     port: env.PORT ? Number(env.PORT) : 3000,
     authToken: env.AUTH_TOKEN ?? randomBytes(24).toString('hex'),
     authTokenGenerated,
-    dataDir: path.resolve(env.DATA_DIR ?? './data'),
+    dataDir,
     workspaceRoots,
+    worktreeRoot: path.resolve(env.WORKTREE_ROOT ?? path.join(dataDir, 'worktrees')),
     engines: (env.ENGINES ?? 'claude-code,echo').split(',').map((s) => s.trim()).filter(Boolean),
     claudeBin: env.CLAUDE_BIN || undefined,
     logLevel: env.LOG_LEVEL ?? 'info',
diff --git a/server/src/db/database.ts b/server/src/db/database.ts
index dca6410..71570fe 100644
--- a/server/src/db/database.ts
+++ b/server/src/db/database.ts
@@ -75,6 +75,14 @@ UPDATE sessions SET engine_state =
     sql: `
 ALTER TABLE sessions ADD COLUMN parent_session_id TEXT;
 ALTER TABLE sessions ADD COLUMN fork_pending INTEGER NOT NULL DEFAULT 0;
+`,
+  },
+  {
+    // Isolated worktree sessions: the hub-managed worktree path (null otherwise),
+    // used to clean up the worktree + its hub/… branch on delete.
+    id: 5,
+    sql: `
+ALTER TABLE sessions ADD COLUMN worktree_path TEXT;
 `,
   },
 ];
diff --git a/server/src/db/repos.ts b/server/src/db/repos.ts
index 10e0a99..ba9fff9 100644
--- a/server/src/db/repos.ts
+++ b/server/src/db/repos.ts
@@ -27,6 +27,7 @@ interface SessionRow {
   settings: string | null;
   parent_session_id: string | null;
   fork_pending: number;
+  worktree_path: string | null;
 }
 
 function toDto(r: SessionRow): SessionDto {
@@ -48,6 +49,7 @@ function toDto(r: SessionRow): SessionDto {
     requestedModel: r.requested_model,
     settings: r.settings,
     parentId: r.parent_session_id,
+    worktreePath: r.worktree_path,
   };
 }
 
@@ -62,15 +64,27 @@ export class SessionsRepo {
     permissionMode: PermissionMode | null;
     model: string | null;
     settings: string | null;
+    worktreePath?: string | null;
   }): SessionDto {
     const now = Date.now();
     this.db
       .prepare(
         `INSERT INTO sessions
-           (id, title, engine_id, cwd, permission_mode, requested_model, settings, status, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, 'idle', ?, ?)`,
+           (id, title, engine_id, cwd, permission_mode, requested_model, settings, worktree_path, status, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'idle', ?, ?)`,
       )
-      .run(s.id, s.title, s.engineId, s.cwd, s.permissionMode, s.model, s.settings, now, now);
+      .run(
+        s.id,
+        s.title,
+        s.engineId,
+        s.cwd,
+        s.permissionMode,
+        s.model,
+        s.settings,
+        s.worktreePath ?? null,
+        now,
+        now,
+      );
     return this.get(s.id)!;
   }
 
diff --git a/server/src/fs/git.ts b/server/src/fs/git.ts
new file mode 100644
index 0000000..6e8bb48
--- /dev/null
+++ b/server/src/fs/git.ts
@@ -0,0 +1,90 @@
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import type { GitInfoResponse } from '@hub/shared';
+
+const GIT_TIMEOUT_MS = 5_000;
+const GIT_WORKTREE_TIMEOUT_MS = 30_000;
+
+function run(cwd: string, args: string[], timeout = GIT_TIMEOUT_MS): { ok: boolean; out: string } {
+  const r = spawnSync('git', ['-C', cwd, ...args], { encoding: 'utf8', timeout });
+  return { ok: r.status === 0 && !r.error, out: (r.stdout ?? '').trim() };
+}
+
+/**
+ * Branch info for a directory, best-effort: returns `isRepo: false` for anything
+ * that is not a git work tree (never throws). Used to populate the launcher.
+ */
+export function gitInfo(cwd: string): GitInfoResponse {
+  const inside = run(cwd, ['rev-parse', '--is-inside-work-tree']);
+  if (!inside.ok || inside.out !== 'true') {
+    return { isRepo: false, currentBranch: null, defaultBranch: null, branches: [] };
+  }
+  const head = run(cwd, ['rev-parse', '--abbrev-ref', 'HEAD']);
+  const currentBranch = head.ok && head.out && head.out !== 'HEAD' ? head.out : null;
+
+  const list = run(cwd, ['for-each-ref', '--format=%(refname:short)', 'refs/heads']);
+  const branches = list.ok ? list.out.split('\n').map((s) => s.trim()).filter(Boolean) : [];
+
+  let defaultBranch: string | null = null;
+  const originHead = run(cwd, ['symbolic-ref', '--short', 'refs/remotes/origin/HEAD']);
+  if (originHead.ok && originHead.out) defaultBranch = originHead.out.replace(/^origin\//, '');
+  else if (branches.includes('main')) defaultBranch = 'main';
+  else if (branches.includes('master')) defaultBranch = 'master';
+  else defaultBranch = currentBranch;
+
+  return { isRepo: true, currentBranch, defaultBranch, branches };
+}
+
+/**
+ * Create a linked worktree at `worktreePath` on a NEW branch `newBranch` based on
+ * `baseBranch`. Creating a new branch avoids the "branch already checked out"
+ * conflict and never touches the source repo's working tree. Throws on failure.
+ */
+export function addWorktree(
+  repo: string,
+  baseBranch: string,
+  worktreePath: string,
+  newBranch: string,
+): void {
+  const r = spawnSync(
+    'git',
+    ['-C', repo, 'worktree', 'add', '-b', newBranch, worktreePath, baseBranch],
+    { encoding: 'utf8', timeout: GIT_WORKTREE_TIMEOUT_MS },
+  );
+  if (r.status !== 0 || r.error) {
+    const detail = (r.stderr ?? r.error?.message ?? '').trim().slice(-300);
+    throw new Error(`git worktree add failed: ${detail || `exit ${r.status}`}`);
+  }
+}
+
+/**
+ * Best-effort removal of a hub-created worktree and its `hub/…` branch. Resolves
+ * the main repo from the worktree so `worktree remove` runs from a valid worktree.
+ * Never throws (cleanup path).
+ */
+export function removeWorktree(worktreePath: string): void {
+  const common = spawnSync(
+    'git',
+    ['-C', worktreePath, 'rev-parse', '--path-format=absolute', '--git-common-dir'],
+    { encoding: 'utf8', timeout: GIT_TIMEOUT_MS },
+  );
+  if (common.status !== 0 || !common.stdout) return; // already gone / not a repo
+  const mainRepo = path.dirname(common.stdout.trim()); // .../repo/.git -> .../repo
+
+  const br = spawnSync('git', ['-C', worktreePath, 'rev-parse', '--abbrev-ref', 'HEAD'], {
+    encoding: 'utf8',
+    timeout: GIT_TIMEOUT_MS,
+  });
+  const branch = br.status === 0 ? (br.stdout ?? '').trim() : '';
+
+  const rm = spawnSync('git', ['-C', mainRepo, 'worktree', 'remove', '--force', worktreePath], {
+    encoding: 'utf8',
+    timeout: GIT_WORKTREE_TIMEOUT_MS,
+  });
+  if (rm.status !== 0) spawnSync('git', ['-C', mainRepo, 'worktree', 'prune'], { timeout: GIT_TIMEOUT_MS });
+
+  // Only ever delete hub-managed branches, never a user branch.
+  if (branch.startsWith('hub/')) {
+    spawnSync('git', ['-C', mainRepo, 'branch', '-D', branch], { timeout: GIT_TIMEOUT_MS });
+  }
+}
diff --git a/server/src/sessions/SessionManager.ts b/server/src/sessions/SessionManager.ts
index 1051f5f..7786bf0 100644
--- a/server/src/sessions/SessionManager.ts
+++ b/server/src/sessions/SessionManager.ts
@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto';
-import { readFileSync } from 'node:fs';
+import { mkdirSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import type { CreateSessionRequest, SessionDto, UpdateSessionRequest } from '@hub/shared';
 import type { HubBus } from '../bus.js';
@@ -8,6 +8,7 @@ import type { EventsRepo, SessionsRepo } from '../db/repos.js';
 import type { EngineRegistry } from '../engines/registry.js';
 import { presetToPermissionMode } from '../approvals/permissionMode.js';
 import { validateCwd } from '../fs/workspace.js';
+import { addWorktree, gitInfo, removeWorktree } from '../fs/git.js';
 import { HubError, SessionRuntime } from './SessionRuntime.js';
 
 export class SessionManager {
@@ -74,20 +75,52 @@ export class SessionManager {
     if (!cwdCheck.ok || !cwdCheck.resolved) {
       throw new HubError('invalid_cwd', cwdCheck.error ?? 'Invalid working directory');
     }
+    const repo = cwdCheck.resolved;
     // permissionMode is canonical; the legacy approvalMode preset is a fallback.
     // Unset => null => the CLI/`~/.claude` default (which is `manual`).
     const permissionMode =
       req.permissionMode ?? (req.approvalMode ? presetToPermissionMode(req.approvalMode) : null);
+
+    const id = randomUUID();
+    // Optionally isolate the session in a fresh git worktree so its edits never
+    // touch the source repo's working tree. The worktree lives under a hub-owned
+    // root and becomes the session cwd (trusted, not re-checked against roots).
+    let cwd = repo;
+    let worktreePath: string | null = null;
+    if (req.worktree) {
+      if (!cwdCheck.isGitRepo) {
+        throw new HubError('worktree_failed', 'Isolated worktree requires a git repository.');
+      }
+      const info = gitInfo(repo);
+      const base = req.branch || info.currentBranch || info.defaultBranch;
+      if (!base) throw new HubError('worktree_failed', 'Could not determine a base branch.');
+      const wt = path.join(this.config.worktreeRoot, id);
+      try {
+        mkdirSync(this.config.worktreeRoot, { recursive: true });
+        addWorktree(repo, base, wt, `hub/${id.slice(0, 8)}`);
+      } catch (err) {
+        throw new HubError('worktree_failed', (err as Error).message);
+      }
+      cwd = wt;
+      worktreePath = wt;
+    }
+
     const dto = this.sessions.create({
-      id: randomUUID(),
-      title: req.title?.trim() || `${path.basename(cwdCheck.resolved)} · ${engine.name}`,
+      id,
+      title: req.title?.trim() || `${path.basename(repo)} · ${engine.name}`,
       engineId: req.engineId,
-      cwd: cwdCheck.resolved,
+      cwd,
       permissionMode,
       model: req.model ?? null,
       settings: req.settings ?? null,
+      worktreePath,
     });
     this.bus.emit('session_upsert', dto);
+
+    // Launch-with-a-task: send the first message so the engine spawns and runs.
+    const prompt = req.initialPrompt?.trim();
+    if (prompt) this.runtime(dto.id).sendUserMessage(prompt);
+
     return dto;
   }
 
@@ -153,6 +186,14 @@ export class SessionManager {
     if (!existing) throw new HubError('not_found', 'Session not found');
     this.runtimes.get(id)?.dispose();
     this.runtimes.delete(id);
+    // Clean up an isolated worktree (and its hub/… branch) after the engine is gone.
+    if (existing.worktreePath) {
+      try {
+        removeWorktree(existing.worktreePath);
+      } catch {
+        /* best-effort cleanup */
+      }
+    }
     this.sessions.delete(id); // events cascade
     this.bus.emit('session_deleted', id);
   }
diff --git a/server/test/e2e.test.ts b/server/test/e2e.test.ts
index 365223b..5d8d42f 100644
--- a/server/test/e2e.test.ts
+++ b/server/test/e2e.test.ts
@@ -1,4 +1,5 @@
-import { mkdtempSync, rmSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import WebSocket from 'ws';
@@ -17,6 +18,7 @@ function testConfig(dataDir: string, workspaceRoot: string): HubConfig {
     authTokenGenerated: false,
     dataDir,
     workspaceRoots: [workspaceRoot],
+    worktreeRoot: path.join(dataDir, 'worktrees'),
     engines: ['echo'],
     claudeBin: undefined,
     logLevel: 'silent',
@@ -501,4 +503,61 @@ describe('end-to-end with echo engine', () => {
     c.close();
     await server.close();
   }, 15_000);
+
+  it('runs a session in an isolated worktree, auto-runs the initial prompt, cleans up on delete', async () => {
+    server = await buildServer(testConfig(dataDir, workspace));
+    const port = server.address.port;
+    const c = new Client(port);
+    await c.open();
+    c.send({ type: 'auth', token: TOKEN });
+    await c.next((m) => m.type === 'auth_ok');
+
+    // A real git repo inside the workspace root.
+    const repo = path.join(workspace, 'proj');
+    mkdirSync(repo, { recursive: true });
+    const g = (args: string[]): void => {
+      const r = spawnSync('git', ['-C', repo, ...args], { encoding: 'utf8' });
+      if (r.status !== 0) throw new Error(`git ${args.join(' ')}: ${r.stderr}`);
+    };
+    g(['init', '-b', 'main']);
+    g(['config', 'user.email', 't@e.com']);
+    g(['config', 'user.name', 'T']);
+    writeFileSync(path.join(repo, 'f.txt'), 'hi\n');
+    g(['add', '.']);
+    g(['commit', '-m', 'init']);
+
+    // Create an isolated worktree session that launches with a task.
+    const session = await api<SessionDto>(port, 'POST', '/api/sessions', {
+      engineId: 'echo',
+      cwd: repo,
+      worktree: true,
+      permissionMode: 'bypassPermissions',
+      initialPrompt: 'go',
+    });
+    expect(session.worktreePath).toBeTruthy();
+    expect(session.cwd).toBe(session.worktreePath);
+    expect(session.cwd.startsWith(path.join(dataDir, 'worktrees'))).toBe(true);
+    expect(existsSync(session.cwd)).toBe(true);
+
+    // The initial prompt auto-ran a turn without a manual send.
+    c.send({ type: 'subscribe', sessionId: session.id, afterEventId: 0 });
+    await c.next(
+      (m) => m.type === 'event' && m.sessionId === session.id && m.event.type === 'done',
+      10_000,
+    );
+    const userTexts = c
+      .events(session.id)
+      .filter((e) => e.event.type === 'message' && (e.event as { role: string }).role === 'user')
+      .map((e) => (e.event as { text: string }).text);
+    expect(userTexts).toContain('go');
+
+    // Delete removes the worktree; the source repo's tree is untouched.
+    const wt = session.worktreePath!;
+    await api(port, 'DELETE', `/api/sessions/${session.id}`);
+    expect(existsSync(wt)).toBe(false);
+    expect(existsSync(path.join(repo, 'f.txt'))).toBe(true);
+
+    c.close();
+    await server.close();
+  }, 20_000);
 });
diff --git a/server/test/git.test.ts b/server/test/git.test.ts
new file mode 100644
index 0000000..13a57f0
--- /dev/null
+++ b/server/test/git.test.ts
@@ -0,0 +1,57 @@
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { addWorktree, gitInfo, removeWorktree } from '../src/fs/git.js';
+
+function git(cwd: string, args: string[]): void {
+  const r = spawnSync('git', ['-C', cwd, ...args], { encoding: 'utf8' });
+  if (r.status !== 0) throw new Error(`git ${args.join(' ')} failed: ${r.stderr}`);
+}
+
+describe('git helper', () => {
+  const repo = mkdtempSync(path.join(tmpdir(), 'hub-git-'));
+  const wtRoot = mkdtempSync(path.join(tmpdir(), 'hub-wt-'));
+
+  beforeAll(() => {
+    git(repo, ['init', '-b', 'main']);
+    git(repo, ['config', 'user.email', 'test@example.com']);
+    git(repo, ['config', 'user.name', 'Test']);
+    writeFileSync(path.join(repo, 'README.md'), '# test\n');
+    git(repo, ['add', '.']);
+    git(repo, ['commit', '-m', 'init']);
+    git(repo, ['branch', 'feature']);
+  });
+
+  afterAll(() => {
+    rmSync(repo, { recursive: true, force: true });
+    rmSync(wtRoot, { recursive: true, force: true });
+  });
+
+  it('reports branch info for a repo', () => {
+    const info = gitInfo(repo);
+    expect(info.isRepo).toBe(true);
+    expect(info.currentBranch).toBe('main');
+    expect(info.branches.sort()).toEqual(['feature', 'main']);
+  });
+
+  it('reports isRepo:false for a non-repo dir', () => {
+    const info = gitInfo(wtRoot);
+    expect(info.isRepo).toBe(false);
+    expect(info.branches).toEqual([]);
+  });
+
+  it('adds and removes an isolated worktree on a new hub/ branch', () => {
+    const wt = path.join(wtRoot, 'session-1');
+    addWorktree(repo, 'main', wt, 'hub/session-1');
+    expect(existsSync(path.join(wt, 'README.md'))).toBe(true);
+    // The worktree is on the new branch; the source repo's HEAD is untouched.
+    expect(gitInfo(wt).currentBranch).toBe('hub/session-1');
+    expect(gitInfo(repo).currentBranch).toBe('main');
+
+    removeWorktree(wt);
+    expect(existsSync(wt)).toBe(false);
+    expect(gitInfo(repo).branches).not.toContain('hub/session-1');
+  });
+});
diff --git a/shared/src/api.ts b/shared/src/api.ts
index 1cd3aaa..4442ed3 100644
--- a/shared/src/api.ts
+++ b/shared/src/api.ts
@@ -39,6 +39,8 @@ export interface SessionDto {
   settings: string | null;
   /** If this session was forked from another, the parent's id (else null). */
   parentId: string | null;
+  /** If the session runs in a hub-managed isolated git worktree, its path (else null). */
+  worktreePath: string | null;
 }
 
 export interface CreateSessionRequest {
@@ -51,6 +53,12 @@ export interface CreateSessionRequest {
   approvalMode?: ApprovalMode;
   model?: string;
   settings?: string;
+  /** Base branch for an isolated worktree (only used when `worktree` is true). */
+  branch?: string;
+  /** Run the session in a fresh, isolated git worktree (requires a git repo cwd). */
+  worktree?: boolean;
+  /** If set, sent as the first user message so the agent starts working immediately. */
+  initialPrompt?: string;
 }
 
 export interface UpdateSessionRequest {
@@ -89,3 +97,10 @@ export interface FsBrowseResponse {
   parent: string | null;
   entries: FsBrowseEntry[];
 }
+
+export interface GitInfoResponse {
+  isRepo: boolean;
+  currentBranch: string | null;
+  defaultBranch: string | null;
+  branches: string[];
+}
diff --git a/web/src/App.svelte b/web/src/App.svelte
index fd28573..f67555c 100644
--- a/web/src/App.svelte
+++ b/web/src/App.svelte
@@ -1,11 +1,12 @@
 <script lang="ts">
   import { onMount } from 'svelte';
-  import { activeSessionId, connState, sessions, token, upsertSession } from './lib/stores.js';
+  import { activeSessionId, sessions, token, upsertSession } from './lib/stores.js';
   import { api } from './lib/api.js';
   import { connect, disconnect, onWsError } from './lib/ws.js';
   import LoginGate from './components/LoginGate.svelte';
   import SessionSidebar from './components/SessionSidebar.svelte';
   import ChatView from './components/ChatView.svelte';
+  import Launcher from './components/Launcher.svelte';
 
   let toast: string | null = $state(null);
   let toastTimer: ReturnType<typeof setTimeout> | undefined;
@@ -49,13 +50,7 @@
       {#if $activeSessionId && $sessions.some((s) => s.id === $activeSessionId)}
         <ChatView sessionId={$activeSessionId} {showToast} />
       {:else}
-        <div class="empty">
-          <h2>agentic-cli-hub</h2>
-          <p>Select a session on the left, or create a new one.</p>
-          {#if $connState !== 'online'}
-            <p class="conn">connection: {$connState}</p>
-          {/if}
-        </div>
+        <Launcher {showToast} />
       {/if}
     </main>
   </div>
@@ -76,17 +71,6 @@
     height: 100%;
     overflow: hidden;
   }
-  .empty {
-    height: 100%;
-    display: flex;
-    flex-direction: column;
-    align-items: center;
-    justify-content: center;
-    color: var(--text-dim);
-  }
-  .conn {
-    font-size: 12px;
-  }
   .toast {
     position: fixed;
     bottom: 18px;
diff --git a/web/src/components/Launcher.svelte b/web/src/components/Launcher.svelte
new file mode 100644
index 0000000..f916327
--- /dev/null
+++ b/web/src/components/Launcher.svelte
@@ -0,0 +1,469 @@
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import type {
+    EngineDescriptor,
+    FsBrowseResponse,
+    FsValidateResponse,
+    GitInfoResponse,
+    PermissionMode,
+  } from '@hub/shared';
+  import { api } from '../lib/api.js';
+  import { PERMISSION_MODES } from '../lib/format.js';
+  import { activeSessionId, sessions, upsertSession } from '../lib/stores.js';
+
+  let { showToast }: { showToast: (m: string) => void } = $props();
+
+  let engines = $state<EngineDescriptor[]>([]);
+  let engineId = $state('');
+  let cwd = $state('');
+  let validation = $state<FsValidateResponse | null>(null);
+  let git = $state<GitInfoResponse | null>(null);
+  let browseData = $state<FsBrowseResponse | null>(null);
+  let showBrowse = $state(false);
+  let useWorktree = $state(false);
+  let branch = $state('');
+  let branchTouched = false;
+  let task = $state('');
+  let permissionMode = $state<PermissionMode | null>(null);
+  let model = $state('');
+  let settings = $state('');
+  let showAdvanced = $state(false);
+  let launching = $state(false);
+  let error = $state<string | null>(null);
+  let validateTimer: ReturnType<typeof setTimeout> | undefined;
+
+  const availableEngines = $derived(engines.filter((e) => e.available));
+  const showEnginePicker = $derived(availableEngines.length > 1);
+  const selectedMode = $derived(PERMISSION_MODES.find((m) => m.value === permissionMode));
+  // Real project dirs from prior sessions (exclude ephemeral worktree sessions).
+  const recentProjects = $derived([
+    ...new Set($sessions.filter((s) => !s.worktreePath).map((s) => s.cwd)),
+  ].slice(0, 6));
+  const canLaunch = $derived(!launching && !!engineId && !!validation?.ok);
+
+  onMount(async () => {
+    try {
+      engines = await api.engines();
+      engineId = engines.find((e) => e.available)?.id ?? '';
+    } catch (e) {
+      error = (e as Error).message;
+    }
+  });
+
+  function resetProject(): void {
+    validation = null;
+    git = null;
+    branch = '';
+    branchTouched = false;
+    useWorktree = false;
+    showBrowse = false;
+  }
+
+  function onCwdInput(): void {
+    resetProject();
+    if (validateTimer) clearTimeout(validateTimer);
+    const value = cwd.trim();
+    if (!value) return;
+    validateTimer = setTimeout(() => void runValidate(value), 300);
+  }
+
+  async function runValidate(value: string): Promise<void> {
+    try {
+      validation = await api.fsValidate(value);
+      if (validation.ok && validation.isGitRepo && validation.resolved) {
+        git = await api.gitInfo(validation.resolved);
+        if (!branchTouched) branch = git.currentBranch ?? git.defaultBranch ?? '';
+      }
+    } catch {
+      validation = null;
+    }
+  }
+
+  function pickRecent(path: string): void {
+    cwd = path;
+    onCwdInput();
+  }
+
+  async function openBrowse(path?: string): Promise<void> {
+    try {
+      browseData = await api.fsBrowse(path);
+      showBrowse = true;
+    } catch (e) {
+      error = (e as Error).message;
+    }
+  }
+
+  function pickDir(path: string): void {
+    cwd = path;
+    showBrowse = false;
+    onCwdInput();
+  }
+
+  async function launch(): Promise<void> {
+    if (!canLaunch) return;
+    launching = true;
+    error = null;
+    try {
+      const dto = await api.createSession({
+        engineId,
+        cwd: cwd.trim(),
+        permissionMode: permissionMode ?? undefined,
+        model: model.trim() || undefined,
+        settings: settings.trim() || undefined,
+        worktree: useWorktree || undefined,
+        branch: useWorktree ? branch.trim() || undefined : undefined,
+        initialPrompt: task.trim() || undefined,
+      });
+      upsertSession(dto);
+      activeSessionId.set(dto.id);
+    } catch (e) {
+      error = (e as Error).message;
+    } finally {
+      launching = false;
+    }
+  }
+
+  function onTaskKeydown(e: KeyboardEvent): void {
+    if (e.key === 'Enter' && !e.shiftKey) {
+      e.preventDefault();
+      void launch();
+    }
+  }
+
+  function baseName(p: string): string {
+    return p.replace(/\/+$/, '').split('/').pop() || p;
+  }
+</script>
+
+<div class="launcher">
+  <div class="inner">
+    <h1>Let's build.</h1>
+    <p class="sub">Point a session at a project, optionally isolate it, and give it a task.</p>
+
+    {#if engines.length && !availableEngines.length}
+      <div class="cta">
+        No engine is available. Install and authenticate a CLI (e.g. <code>claude login</code>),
+        then reload.
+      </div>
+    {/if}
+
+    {#if recentProjects.length}
+      <div class="recent">
+        <span class="field-label">Recent projects</span>
+        <div class="chips">
+          {#each recentProjects as p (p)}
+            <button type="button" class="chip" title={p} onclick={() => pickRecent(p)}>
+              {baseName(p)}
+            </button>
+          {/each}
+        </div>
+      </div>
+    {/if}
+
+    <label class="field">
+      <span class="field-label">Project directory</span>
+      <div class="row">
+        <input
+          placeholder="/home/you/code/my-repo"
+          bind:value={cwd}
+          oninput={onCwdInput}
+          spellcheck="false"
+        />
+        <button type="button" onclick={() => openBrowse(validation?.ok ? cwd : undefined)}>Browse…</button>
+      </div>
+      {#if validation}
+        {#if validation.ok}
+          <span class="hint ok">✓ {validation.resolved}{validation.isGitRepo ? ' · git repo' : ''}</span>
+        {:else}
+          <span class="hint bad">✗ {validation.error}</span>
+        {/if}
+      {/if}
+    </label>
+
+    {#if showBrowse && browseData}
+      <div class="browser">
+        <div class="browser-path">
+          {#if browseData.parent !== null || browseData.path}
+            <button type="button" class="icon" onclick={() => openBrowse(browseData?.parent ?? undefined)}>↑</button>
+          {/if}
+          <span>{browseData.path || '(workspace roots)'}</span>
+        </div>
+        <div class="browser-list">
+          {#each browseData.entries as entry (entry.path)}
+            <div class="browser-entry">
+              <button type="button" class="entry-name" onclick={() => openBrowse(entry.path)}>
+                📁 {entry.name}{entry.isGitRepo ? ' ⎇' : ''}
+              </button>
+              <button type="button" class="entry-pick" onclick={() => pickDir(entry.path)}>select</button>
+            </div>
+          {:else}
+            <p class="hint">no subdirectories</p>
+          {/each}
+        </div>
+        {#if browseData.path}
+          <button type="button" onclick={() => pickDir(browseData!.path)}>Use this directory</button>
+        {/if}
+      </div>
+    {/if}
+
+    {#if git?.isRepo}
+      <div class="field git">
+        <span class="hint dim">on branch: <strong>{git.currentBranch ?? '(detached)'}</strong></span>
+        <label class="check">
+          <input type="checkbox" bind:checked={useWorktree} />
+          Isolate in a new git worktree
+          <span class="hint dim">(new hub/… branch; never touches your working tree)</span>
+        </label>
+        {#if useWorktree}
+          <label class="field sub-field">
+            <span class="field-label">Base new worktree on</span>
+            <input
+              list="branch-list"
+              bind:value={branch}
+              oninput={() => (branchTouched = true)}
+              placeholder="branch"
+              spellcheck="false"
+            />
+            <datalist id="branch-list">
+              {#each git.branches as b (b)}<option value={b}></option>{/each}
+            </datalist>
+          </label>
+        {/if}
+      </div>
+    {/if}
+
+    <label class="field">
+      <span class="field-label">Task (optional)</span>
+      <textarea
+        rows="3"
+        placeholder="Describe what to work on. Enter launches, Shift+Enter for a newline."
+        bind:value={task}
+        onkeydown={onTaskKeydown}
+      ></textarea>
+    </label>
+
+    <div class="advanced">
+      <button type="button" class="disclosure" onclick={() => (showAdvanced = !showAdvanced)}>
+        {showAdvanced ? '▾' : '▸'} Advanced
+      </button>
+      {#if showAdvanced}
+        <div class="advanced-body">
+          {#if showEnginePicker}
+            <label class="field">
+              <span class="field-label">Engine</span>
+              <select bind:value={engineId}>
+                {#each engines as eng (eng.id)}
+                  <option value={eng.id} disabled={!eng.available}>
+                    {eng.name}{eng.version ? ` (${eng.version})` : ''}{eng.available
+                      ? ''
+                      : ` — ${eng.unavailableReason ?? 'unavailable'}`}
+                  </option>
+                {/each}
+              </select>
+            </label>
+          {/if}
+
+          <label class="field" class:danger={selectedMode?.danger}>
+            <span class="field-label">Permission mode</span>
+            <select bind:value={permissionMode}>
+              {#each PERMISSION_MODES as m (m.value ?? 'inherit')}
+                <option value={m.value}>{m.label}</option>
+              {/each}
+            </select>
+            {#if selectedMode?.hint}<span class="hint dim">{selectedMode.hint}</span>{/if}
+          </label>
+
+          <label class="field">
+            <span class="field-label">Model (optional)</span>
+            <input placeholder="inherit ~/.claude (e.g. opus, sonnet)" bind:value={model} spellcheck="false" />
+          </label>
+
+          <label class="field">
+            <span class="field-label">Settings (optional)</span>
+            <input placeholder="--settings path or inline JSON" bind:value={settings} spellcheck="false" />
+          </label>
+        </div>
+      {/if}
+    </div>
+
+    {#if error}<p class="hint bad">{error}</p>{/if}
+
+    <div class="actions">
+      <button class="primary launch" onclick={launch} disabled={!canLaunch}>
+        {launching ? 'Launching…' : useWorktree ? 'Launch (isolated)' : 'Launch'}
+      </button>
+    </div>
+  </div>
+</div>
+
+<style>
+  .launcher {
+    height: 100%;
+    overflow-y: auto;
+    display: flex;
+    justify-content: center;
+  }
+  .inner {
+    width: 100%;
+    max-width: 640px;
+    padding: 48px 24px 60px;
+    display: flex;
+    flex-direction: column;
+    gap: 16px;
+  }
+  h1 {
+    margin: 0;
+    font-size: 26px;
+  }
+  .sub {
+    margin: 0;
+    color: var(--text-dim);
+    font-size: 13px;
+  }
+  .field {
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+  }
+  .field-label {
+    font-size: 12px;
+    color: var(--text-dim);
+  }
+  .row {
+    display: flex;
+    gap: 8px;
+  }
+  .row input {
+    flex: 1;
+  }
+  .hint {
+    font-size: 12px;
+  }
+  .hint.dim {
+    color: var(--text-dim);
+  }
+  .ok {
+    color: var(--green);
+  }
+  .bad {
+    color: var(--red);
+  }
+  .recent {
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+  }
+  .chips {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 6px;
+  }
+  .chip {
+    font-size: 12px;
+    padding: 4px 10px;
+    border-radius: 999px;
+    background: var(--bg-raised);
+    border: 1px solid var(--border);
+  }
+  .cta {
+    border: 1px solid var(--amber);
+    border-radius: 8px;
+    padding: 10px 12px;
+    font-size: 13px;
+    background: color-mix(in srgb, var(--amber) 6%, var(--bg-panel));
+  }
+  .git {
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    padding: 10px 12px;
+    gap: 8px;
+  }
+  .check {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-size: 13px;
+  }
+  .sub-field {
+    margin-top: 2px;
+  }
+  textarea {
+    resize: vertical;
+    min-height: 60px;
+  }
+  .advanced {
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+  }
+  .disclosure {
+    align-self: flex-start;
+    background: none;
+    border: none;
+    color: var(--text-dim);
+    padding: 2px 0;
+    font-size: 13px;
+  }
+  .advanced-body {
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+    border-left: 2px solid var(--border);
+    padding-left: 12px;
+  }
+  .field.danger .field-label,
+  .field.danger :global(select) {
+    color: var(--red);
+  }
+  .actions {
+    display: flex;
+    justify-content: flex-end;
+    margin-top: 4px;
+  }
+  .launch {
+    padding: 8px 22px;
+    font-size: 14px;
+  }
+  .browser {
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    padding: 10px;
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+    font-size: 13px;
+  }
+  .browser-path {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-family: var(--mono);
+    font-size: 12px;
+    color: var(--text-dim);
+  }
+  .browser-list {
+    max-height: 200px;
+    overflow-y: auto;
+    display: flex;
+    flex-direction: column;
+  }
+  .browser-entry {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+  }
+  .entry-name {
+    background: none;
+    border: none;
+    text-align: left;
+    flex: 1;
+    padding: 4px 6px;
+  }
+  .entry-pick {
+    font-size: 11px;
+    padding: 2px 8px;
+  }
+  .icon {
+    padding: 2px 8px;
+  }
+</style>
diff --git a/web/src/components/NewSessionDialog.svelte b/web/src/components/NewSessionDialog.svelte
deleted file mode 100644
index ff27548..0000000
--- a/web/src/components/NewSessionDialog.svelte
+++ /dev/null
@@ -1,308 +0,0 @@
-<script lang="ts">
-  import { onMount } from 'svelte';
-  import type {
-    EngineDescriptor,
-    FsBrowseResponse,
-    FsValidateResponse,
-    PermissionMode,
-  } from '@hub/shared';
-  import { api } from '../lib/api.js';
-  import { PERMISSION_MODES } from '../lib/format.js';
-
-  let { close, created }: { close: () => void; created: (id: string) => void } = $props();
-
-  let engines: EngineDescriptor[] = $state([]);
-  let engineId = $state('');
-  let cwd = $state('');
-  let title = $state('');
-  // null = inherit the directory's ~/.claude default.
-  let permissionMode = $state<PermissionMode | null>(null);
-  let model = $state('');
-  let validation: FsValidateResponse | null = $state(null);
-  let browseData: FsBrowseResponse | null = $state(null);
-  let showBrowse = $state(false);
-  let error: string | null = $state(null);
-  let busy = $state(false);
-  let validateTimer: ReturnType<typeof setTimeout> | undefined;
-
-  onMount(async () => {
-    try {
-      engines = await api.engines();
-      engineId = engines.find((e) => e.available)?.id ?? '';
-    } catch (e) {
-      error = (e as Error).message;
-    }
-  });
-
-  function onCwdInput(): void {
-    validation = null;
-    if (validateTimer) clearTimeout(validateTimer);
-    const value = cwd.trim();
-    if (!value) return;
-    validateTimer = setTimeout(async () => {
-      try {
-        validation = await api.fsValidate(value);
-      } catch {
-        validation = null;
-      }
-    }, 300);
-  }
-
-  async function openBrowse(path?: string): Promise<void> {
-    try {
-      browseData = await api.fsBrowse(path);
-      showBrowse = true;
-    } catch (e) {
-      error = (e as Error).message;
-    }
-  }
-
-  function pick(path: string): void {
-    cwd = path;
-    showBrowse = false;
-    onCwdInput();
-  }
-
-  async function submit(e: SubmitEvent): Promise<void> {
-    e.preventDefault();
-    busy = true;
-    error = null;
-    try {
-      const dto = await api.createSession({
-        engineId,
-        cwd: cwd.trim(),
-        permissionMode: permissionMode ?? undefined,
-        model: model.trim() || undefined,
-        title: title.trim() || undefined,
-      });
-      created(dto.id);
-    } catch (err) {
-      error = (err as Error).message;
-    } finally {
-      busy = false;
-    }
-  }
-</script>
-
-<div
-  class="overlay"
-  onclick={(e) => e.target === e.currentTarget && close()}
-  onkeydown={(e) => e.key === 'Escape' && close()}
-  role="presentation"
->
-  <form class="dialog" onsubmit={submit} aria-label="New session">
-    <h2>New session</h2>
-
-    <label>
-      Engine
-      <select bind:value={engineId}>
-        {#each engines as eng (eng.id)}
-          <option value={eng.id} disabled={!eng.available}>
-            {eng.name}{eng.version ? ` (${eng.version})` : ''}{eng.available
-              ? ''
-              : ` — unavailable: ${eng.unavailableReason ?? 'not found'}`}
-          </option>
-        {/each}
-      </select>
-    </label>
-
-    <label>
-      Working directory
-      <div class="cwd-row">
-        <input
-          placeholder="/home/you/code/my-repo"
-          bind:value={cwd}
-          oninput={onCwdInput}
-          spellcheck="false"
-        />
-        <button type="button" onclick={() => openBrowse(validation?.ok ? cwd : undefined)}>Browse…</button>
-      </div>
-      {#if validation}
-        {#if validation.ok}
-          <span class="hint ok">✓ {validation.resolved}{validation.isGitRepo ? ' (git repo)' : ''}</span>
-        {:else}
-          <span class="hint bad">✗ {validation.error}</span>
-        {/if}
-      {/if}
-    </label>
-
-    {#if showBrowse && browseData}
-      <div class="browser">
-        <div class="browser-path">
-          {#if browseData.parent !== null || browseData.path}
-            <button type="button" class="icon" onclick={() => openBrowse(browseData?.parent ?? undefined)}>↑</button>
-          {/if}
-          <span>{browseData.path || '(workspace roots)'}</span>
-        </div>
-        <div class="browser-list">
-          {#each browseData.entries as entry (entry.path)}
-            <div class="browser-entry">
-              <button type="button" class="entry-name" onclick={() => openBrowse(entry.path)}>
-                📁 {entry.name}{entry.isGitRepo ? ' ⎇' : ''}
-              </button>
-              <button type="button" class="entry-pick" onclick={() => pick(entry.path)}>select</button>
-            </div>
-          {:else}
-            <p class="hint">no subdirectories</p>
-          {/each}
-        </div>
-        {#if browseData.path}
-          <button type="button" onclick={() => pick(browseData!.path)}>Use {browseData.path}</button>
-        {/if}
-      </div>
-    {/if}
-
-    <fieldset>
-      <legend>Permission mode</legend>
-      {#each PERMISSION_MODES as mode (mode.value ?? 'inherit')}
-        <label class="radio" class:danger={mode.danger}>
-          <input type="radio" bind:group={permissionMode} value={mode.value} />
-          {mode.label}
-          <span class="mode-hint">{mode.hint}</span>
-        </label>
-      {/each}
-    </fieldset>
-
-    <label>
-      Model (optional)
-      <input placeholder="inherit ~/.claude (e.g. opus, sonnet)" bind:value={model} spellcheck="false" />
-    </label>
-
-    <label>
-      Title (optional)
-      <input placeholder="auto-generated from directory" bind:value={title} />
-    </label>
-
-    {#if error}<p class="hint bad">{error}</p>{/if}
-
-    <div class="buttons">
-      <button type="button" onclick={close}>Cancel</button>
-      <button class="primary" type="submit" disabled={busy || !engineId || !validation?.ok}>
-        Create
-      </button>
-    </div>
-  </form>
-</div>
-
-<style>
-  .overlay {
-    position: fixed;
-    inset: 0;
-    background: rgba(0, 0, 0, 0.55);
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    z-index: 50;
-  }
-  .dialog {
-    width: 480px;
-    max-height: 88vh;
-    overflow-y: auto;
-    background: var(--bg-panel);
-    border: 1px solid var(--border);
-    border-radius: 12px;
-    padding: 22px;
-    display: flex;
-    flex-direction: column;
-    gap: 14px;
-  }
-  h2 {
-    margin: 0;
-    font-size: 17px;
-  }
-  label {
-    display: flex;
-    flex-direction: column;
-    gap: 6px;
-    font-size: 13px;
-    color: var(--text-dim);
-  }
-  .cwd-row {
-    display: flex;
-    gap: 8px;
-  }
-  .cwd-row input {
-    flex: 1;
-  }
-  .hint {
-    font-size: 12px;
-  }
-  .ok {
-    color: var(--green);
-  }
-  .bad {
-    color: var(--red);
-  }
-  fieldset {
-    border: 1px solid var(--border);
-    border-radius: 8px;
-    display: flex;
-    flex-direction: column;
-    gap: 6px;
-  }
-  legend {
-    font-size: 12px;
-    color: var(--text-dim);
-    padding: 0 6px;
-  }
-  .radio {
-    flex-direction: row;
-    align-items: center;
-    gap: 8px;
-    color: var(--text);
-  }
-  .radio.danger {
-    color: var(--red);
-  }
-  .mode-hint {
-    color: var(--text-dim);
-    font-size: 11px;
-  }
-  .buttons {
-    display: flex;
-    justify-content: flex-end;
-    gap: 8px;
-  }
-  .browser {
-    border: 1px solid var(--border);
-    border-radius: 8px;
-    padding: 10px;
-    display: flex;
-    flex-direction: column;
-    gap: 8px;
-    font-size: 13px;
-  }
-  .browser-path {
-    display: flex;
-    align-items: center;
-    gap: 8px;
-    font-family: var(--mono);
-    font-size: 12px;
-    color: var(--text-dim);
-  }
-  .browser-list {
-    max-height: 180px;
-    overflow-y: auto;
-    display: flex;
-    flex-direction: column;
-  }
-  .browser-entry {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-  }
-  .entry-name {
-    background: none;
-    border: none;
-    text-align: left;
-    flex: 1;
-    padding: 4px 6px;
-  }
-  .entry-pick {
-    font-size: 11px;
-    padding: 2px 8px;
-  }
-  .icon {
-    padding: 2px 8px;
-  }
-</style>
diff --git a/web/src/components/SessionSidebar.svelte b/web/src/components/SessionSidebar.svelte
index 0011c09..bdf3d20 100644
--- a/web/src/components/SessionSidebar.svelte
+++ b/web/src/components/SessionSidebar.svelte
@@ -10,11 +10,9 @@
   import { api } from '../lib/api.js';
   import { disconnect, subscribeSession } from '../lib/ws.js';
   import { engineStateLabel, isDangerMode, relativeTime } from '../lib/format.js';
-  import NewSessionDialog from './NewSessionDialog.svelte';
 
   let { showToast }: { showToast: (m: string) => void } = $props();
 
-  let showNew = $state(false);
   let renamingId: string | null = $state(null);
   let renameValue = $state('');
   let showArchived = $state(false);
@@ -111,7 +109,7 @@
     <span class="conn" title="connection state" data-state={$connState}>●</span>
   </header>
 
-  <button class="primary new" onclick={() => (showNew = true)}>+ New session</button>
+  <button class="primary new" onclick={() => activeSessionId.set(null)}>+ New session</button>
 
   <div class="filters">
     <input class="search" placeholder="Search sessions…" bind:value={filterText} />
@@ -208,16 +206,6 @@
   </footer>
 </aside>
 
-{#if showNew}
-  <NewSessionDialog
-    close={() => (showNew = false)}
-    created={(id) => {
-      showNew = false;
-      select(id);
-    }}
-  />
-{/if}
-
 <style>
   aside {
     display: flex;
diff --git a/web/src/lib/api.ts b/web/src/lib/api.ts
index 5acb5cd..d8037c3 100644
--- a/web/src/lib/api.ts
+++ b/web/src/lib/api.ts
@@ -4,6 +4,7 @@ import type {
   EngineDescriptor,
   FsBrowseResponse,
   FsValidateResponse,
+  GitInfoResponse,
   SessionDto,
   SessionEvent,
   UpdateSessionRequest,
@@ -62,4 +63,6 @@ export const api = {
   fsValidate: (path: string) => request<FsValidateResponse>('POST', '/api/fs/validate', { path }),
   fsBrowse: (path?: string) =>
     request<FsBrowseResponse>('GET', `/api/fs/browse${path ? `?path=${encodeURIComponent(path)}` : ''}`),
+  gitInfo: (cwd: string) =>
+    request<GitInfoResponse>('GET', `/api/git/info?cwd=${encodeURIComponent(cwd)}`),
 };

From bf178442e1be17b889549ec8f64ccc771a7a834b Mon Sep 17 00:00:00 2001
From: "Wit, Floris De (178)" <floris_de.wit@mercedes-benz.com>
Date: Thu, 9 Jul 2026 17:34:15 +0200
Subject: [PATCH 4/5] fix(deploy): make the Docker image build and run

Three latent breaks surfaced building deploy/Dockerfile under the current
toolchain, plus the new git dependency:

- git is now installed in the runtime image (isolated-worktree sessions shell
  out to it; the Claude CLI also uses it).
- .npmrc hoists @sveltejs/vite-plugin-svelte so Vite can load its TS config from
  the temp dir on a fresh (Docker/CI) install, not just a warm local one.
- pnpm v10 `deploy` needs legacy mode (force-legacy-deploy=true); our shared
  package isn't injected.
- /data is created and chowned to the non-root runtime user so SQLite + worktrees
  are writable (a named volume mounted there inherits the ownership).

The image now boots and serves /api/health with git + claude available.
.env.example documents WORKTREE_ROOT.
---
 .npmrc              | 11 +++++++++++
 deploy/.env.example |  3 +++
 deploy/Dockerfile   | 11 +++++++++--
 3 files changed, 23 insertions(+), 2 deletions(-)
 create mode 100644 .npmrc

diff --git a/.npmrc b/.npmrc
new file mode 100644
index 0000000..ef64c66
--- /dev/null
+++ b/.npmrc
@@ -0,0 +1,11 @@
+# Vite loads its TS config from a temp dir (web/node_modules/.vite-temp); under
+# pnpm the Svelte plugin must be resolvable from the workspace root for a fresh
+# (Docker/CI) install, not just a warm local one. Keep pnpm's default hoist
+# patterns for eslint/prettier plugins alongside it.
+public-hoist-pattern[]=*eslint*
+public-hoist-pattern[]=*prettier*
+public-hoist-pattern[]=@sveltejs/vite-plugin-svelte
+
+# `pnpm deploy` (used in deploy/Dockerfile to build the self-contained server
+# tree) needs legacy mode under pnpm v10; our shared package isn't injected.
+force-legacy-deploy=true
diff --git a/deploy/.env.example b/deploy/.env.example
index 235c8a3..ec76a6a 100644
--- a/deploy/.env.example
+++ b/deploy/.env.example
@@ -16,6 +16,9 @@ DATA_DIR=./data
 # Colon-separated list of directories sessions may target as their working
 # directory. Defaults to $HOME. In docker this is the /workspace mount.
 WORKSPACE_ROOTS=
+# Where isolated per-session git worktrees are created. Defaults to
+# $DATA_DIR/worktrees (persisted on the hub-data volume in docker).
+WORKTREE_ROOT=
 
 # --- engines ------------------------------------------------------------
 # Comma-separated engine ids to enable.
diff --git a/deploy/Dockerfile b/deploy/Dockerfile
index 3ac1ef1..53ab570 100644
--- a/deploy/Dockerfile
+++ b/deploy/Dockerfile
@@ -6,7 +6,7 @@ WORKDIR /app
 RUN corepack enable \
  && apt-get update && apt-get install -y --no-install-recommends python3 make g++ \
  && rm -rf /var/lib/apt/lists/*
-COPY package.json pnpm-workspace.yaml pnpm-lock.yaml tsconfig.base.json ./
+COPY package.json pnpm-workspace.yaml pnpm-lock.yaml tsconfig.base.json .npmrc ./
 COPY shared/package.json shared/
 COPY server/package.json server/
 COPY web/package.json web/
@@ -22,7 +22,11 @@ FROM node:22-bookworm-slim
 # Pin the engine CLI version; qualify new versions with `pnpm --filter
 # @hub/server spike` before bumping (the CLI's headless interface can change).
 ARG CLAUDE_CODE_VERSION=2.1.205
-RUN npm install -g @anthropic-ai/claude-code@${CLAUDE_CODE_VERSION} \
+# git is required at runtime: isolated-worktree sessions shell out to it, and
+# the Claude CLI uses it for repo context.
+RUN apt-get update && apt-get install -y --no-install-recommends git \
+ && rm -rf /var/lib/apt/lists/* \
+ && npm install -g @anthropic-ai/claude-code@${CLAUDE_CODE_VERSION} \
  && useradd -m -u 1001 hub
 WORKDIR /opt/hub
 COPY --from=build /out/server ./server
@@ -35,6 +39,9 @@ ENV NODE_ENV=production \
     DATA_DIR=/data \
     WEB_DIST_DIR=/opt/hub/web/dist \
     WORKSPACE_ROOTS=/workspace
+# Own /data (SQLite + isolated worktrees) as the runtime user; a named volume
+# mounted here inherits this ownership on first use.
+RUN mkdir -p /data && chown hub:hub /data
 USER hub
 EXPOSE 3000
 CMD ["node", "server/dist/index.js"]

From 0659714c17933dba6695016eecb2b1fb637af338 Mon Sep 17 00:00:00 2001
From: "Wit, Floris De (178)" <floris_de.wit@mercedes-benz.com>
Date: Thu, 9 Jul 2026 17:34:15 +0200
Subject: [PATCH 5/5] chore(quality): add Prettier + ESLint and CI quality
 gates

- Prettier (house style: width 100, single quotes, trailing commas) + a
  format:check; ESLint flat config (typescript-eslint + eslint-plugin-svelte)
  with a focused ruleset + a lint script. Fixed the few real issues it found
  (keyed {#each}, useless assignment, unused prop).
- CI: least-privilege permissions, concurrency cancellation, per-job timeout,
  and lint + format:check alongside typecheck/test. To keep dev CI fast, CI
  builds only @hub/shared (the dist downstream steps consume); production
  artifact builds (server dist, web Vite bundle) stay in the deploy image, and
  there is no Docker image build in CI.
- One-time Prettier normalization across the codebase (mechanical).
---
 .github/workflows/ci.yml                      |  22 +-
 .prettierignore                               |   5 +
 .prettierrc.json                              |   7 +
 eslint.config.js                              |  37 +
 package.json                                  |  13 +
 pnpm-lock.yaml                                | 876 +++++++++++++++++-
 server/scripts/spike-claude.ts                |  61 +-
 server/src/api/routes.ts                      |  16 +-
 server/src/api/ws.ts                          |  11 +-
 server/src/bus.ts                             |   5 +-
 server/src/config.ts                          |   9 +-
 server/src/db/database.ts                     |   4 +-
 server/src/db/repos.ts                        |  35 +-
 .../src/engines/claude/ClaudeCodeAdapter.ts   |  15 +-
 server/src/engines/echo/EchoAdapter.ts        |  12 +-
 server/src/fs/git.ts                          |  12 +-
 server/src/sessions/SessionRuntime.ts         |   6 +-
 server/test/adapter-contract.ts               |  10 +-
 server/test/e2e.test.ts                       |  31 +-
 shared/src/events.ts                          |   7 +-
 web/src/App.svelte                            |   2 +-
 web/src/app.css                               |  37 +-
 web/src/components/ApprovalCard.svelte        |  12 +-
 web/src/components/ChatView.svelte            |   3 +-
 web/src/components/DoneMarker.svelte          |   4 +-
 web/src/components/Launcher.svelte            |  47 +-
 web/src/components/LoginGate.svelte           |   7 +-
 web/src/components/StatusBar.svelte           |   4 +-
 web/src/components/ToolCallCard.svelte        |  12 +-
 web/src/lib/api.ts                            |  10 +-
 web/src/lib/format.ts                         |  50 +-
 web/src/lib/timeline.ts                       |  12 +-
 32 files changed, 1260 insertions(+), 134 deletions(-)
 create mode 100644 .prettierignore
 create mode 100644 .prettierrc.json
 create mode 100644 eslint.config.js

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 657ba3c..74010b2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -6,9 +6,19 @@ on:
   pull_request:
     branches: [main]
 
+# Least privilege: CI only needs to read the repository.
+permissions:
+  contents: read
+
+# Cancel superseded runs on the same ref (saves CI minutes on rapid pushes).
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
-  build-and-test:
+  quality:
     runs-on: ubuntu-latest
+    timeout-minutes: 15
     steps:
       - uses: actions/checkout@v4
 
@@ -23,10 +33,16 @@ jobs:
       # Builds native deps (better-sqlite3, esbuild) per the onlyBuiltDependencies allowlist.
       - run: pnpm install --frozen-lockfile
 
-      # shared must build before server/web typecheck (they consume its dist/).
-      - run: pnpm build
+      # Only @hub/shared's dist is needed downstream (server/web typecheck + tests
+      # consume it). Production artifact builds (server dist, web Vite bundle) are
+      # left to the deploy image, so CI stays fast during development.
+      - run: pnpm --filter @hub/shared build
 
       - run: pnpm typecheck
 
+      - run: pnpm lint
+
+      - run: pnpm format:check
+
       # Keyless: the live claude CLI test self-skips unless CLAUDE_LIVE=1 (never set here).
       - run: pnpm test
diff --git a/.prettierignore b/.prettierignore
new file mode 100644
index 0000000..8af8d8c
--- /dev/null
+++ b/.prettierignore
@@ -0,0 +1,5 @@
+**/dist/
+**/node_modules/
+data/
+pnpm-lock.yaml
+*.md
diff --git a/.prettierrc.json b/.prettierrc.json
new file mode 100644
index 0000000..efe63f1
--- /dev/null
+++ b/.prettierrc.json
@@ -0,0 +1,7 @@
+{
+  "printWidth": 100,
+  "singleQuote": true,
+  "trailingComma": "all",
+  "plugins": ["prettier-plugin-svelte"],
+  "overrides": [{ "files": "*.svelte", "options": { "parser": "svelte" } }]
+}
diff --git a/eslint.config.js b/eslint.config.js
new file mode 100644
index 0000000..f0e67db
--- /dev/null
+++ b/eslint.config.js
@@ -0,0 +1,37 @@
+import js from '@eslint/js';
+import tseslint from 'typescript-eslint';
+import svelte from 'eslint-plugin-svelte';
+import prettier from 'eslint-config-prettier';
+import globals from 'globals';
+
+export default tseslint.config(
+  { ignores: ['**/dist/', '**/node_modules/', 'data/', 'web/dist/'] },
+
+  js.configs.recommended,
+  tseslint.configs.recommended,
+  svelte.configs.recommended,
+
+  {
+    languageOptions: {
+      globals: { ...globals.node, ...globals.browser },
+    },
+    rules: {
+      // Allow intentionally-unused args/vars prefixed with _, and unbound catches.
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        { argsIgnorePattern: '^_', varsIgnorePattern: '^_', caughtErrors: 'none' },
+      ],
+    },
+  },
+
+  // Svelte <script lang="ts"> needs the TS parser.
+  {
+    files: ['**/*.svelte'],
+    languageOptions: {
+      parserOptions: { parser: tseslint.parser },
+    },
+  },
+
+  // Turn off formatting-related rules; Prettier owns formatting.
+  prettier,
+);
diff --git a/package.json b/package.json
index 2377df2..ebbd27b 100644
--- a/package.json
+++ b/package.json
@@ -11,6 +11,9 @@
     "build": "pnpm -r build",
     "test": "pnpm -r test",
     "typecheck": "pnpm -r typecheck",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
     "start": "node server/dist/index.js"
   },
   "pnpm": {
@@ -18,5 +21,15 @@
       "better-sqlite3",
       "esbuild"
     ]
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.6.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-svelte": "^3.20.0",
+    "globals": "^17.7.0",
+    "prettier": "^3.9.4",
+    "prettier-plugin-svelte": "^4.1.1",
+    "typescript-eslint": "^8.63.0"
   }
 }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index e5ed208..bc6ebb9 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -6,7 +6,32 @@ settings:
 
 importers:
 
-  .: {}
+  .:
+    devDependencies:
+      '@eslint/js':
+        specifier: ^10.0.1
+        version: 10.0.1(eslint@10.6.0)
+      eslint:
+        specifier: ^10.6.0
+        version: 10.6.0
+      eslint-config-prettier:
+        specifier: ^10.1.8
+        version: 10.1.8(eslint@10.6.0)
+      eslint-plugin-svelte:
+        specifier: ^3.20.0
+        version: 3.20.0(eslint@10.6.0)(svelte@5.56.4(@typescript-eslint/types@8.63.0))
+      globals:
+        specifier: ^17.7.0
+        version: 17.7.0
+      prettier:
+        specifier: ^3.9.4
+        version: 3.9.4
+      prettier-plugin-svelte:
+        specifier: ^4.1.1
+        version: 4.1.1(prettier@3.9.4)(svelte@5.56.4(@typescript-eslint/types@8.63.0))
+      typescript-eslint:
+        specifier: ^8.63.0
+        version: 8.63.0(eslint@10.6.0)(typescript@5.9.3)
 
   server:
     dependencies:
@@ -71,16 +96,16 @@ importers:
     devDependencies:
       '@sveltejs/vite-plugin-svelte':
         specifier: ^5.0.3
-        version: 5.1.1(svelte@5.56.4)(vite@6.4.3(@types/node@22.20.1)(tsx@4.23.0))
+        version: 5.1.1(svelte@5.56.4(@typescript-eslint/types@8.63.0))(vite@6.4.3(@types/node@22.20.1)(tsx@4.23.0))
       '@tsconfig/svelte':
         specifier: ^5.0.4
         version: 5.0.8
       svelte:
         specifier: ^5.19.0
-        version: 5.56.4
+        version: 5.56.4(@typescript-eslint/types@8.63.0)
       svelte-check:
         specifier: ^4.1.4
-        version: 4.7.2(picomatch@4.0.5)(svelte@5.56.4)(typescript@5.9.3)
+        version: 4.7.2(picomatch@4.0.5)(svelte@5.56.4(@typescript-eslint/types@8.63.0))(typescript@5.9.3)
       typescript:
         specifier: ^5.7.3
         version: 5.9.3
@@ -402,6 +427,45 @@ packages:
     cpu: [x64]
     os: [win32]
 
+  '@eslint-community/eslint-utils@4.9.1':
+    resolution: {integrity: sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    peerDependencies:
+      eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
+
+  '@eslint-community/regexpp@4.12.2':
+    resolution: {integrity: sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==}
+    engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
+
+  '@eslint/config-array@0.23.5':
+    resolution: {integrity: sha512-Y3kKLvC1dvTOT+oGlqNQ1XLqK6D1HU2YXPc52NmAlJZbMMWDzGYXMiPRJ8TYD39muD/OTjlZmNJ4ib7dvSrMBA==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  '@eslint/config-helpers@0.6.0':
+    resolution: {integrity: sha512-ii6Bw9jJ2zi2cWA2Z+9/QZ/+3DX6kwaV5Q986D/CdP3Lap3w/pgQZ373FV7byY/i7L4IRH/G43I5dz1ClsCbpA==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  '@eslint/core@1.2.1':
+    resolution: {integrity: sha512-MwcE1P+AZ4C6DWlpin/OmOA54mmIZ/+xZuJiQd4SyB29oAJjN30UW9wkKNptW2ctp4cEsvhlLY/CsQ1uoHDloQ==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  '@eslint/js@10.0.1':
+    resolution: {integrity: sha512-zeR9k5pd4gxjZ0abRoIaxdc7I3nDktoXZk2qOv9gCNWx3mVwEn32VRhyLaRsDiJjTs0xq/T8mfPtyuXu7GWBcA==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+    peerDependencies:
+      eslint: ^10.0.0
+    peerDependenciesMeta:
+      eslint:
+        optional: true
+
+  '@eslint/object-schema@3.0.5':
+    resolution: {integrity: sha512-vqTaUEgxzm+YDSdElad6PiRoX4t8VGDjCtt05zn4nU810UIx/uNEV7/lZJ6KwFThKZOzOxzXy48da+No7HZaMw==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  '@eslint/plugin-kit@0.7.2':
+    resolution: {integrity: sha512-+CNAzxglkrpNf/kKywqQfk74QjtceuOE7Qm+AF8miRvPF/wmmK5+OJOgVh3AVTT3RP2mH3+FOaxlE5v72owk0A==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
   '@fastify/accept-negotiator@2.0.1':
     resolution: {integrity: sha512-/c/TW2bO/v9JeEgoD/g1G5GxGeCF1Hafdf79WPmUlgYiBXummY0oX3VVq4yFkKKVBKDNlaDUYoab7g38RpPqCQ==}
 
@@ -429,6 +493,26 @@ packages:
   '@fastify/static@8.3.0':
     resolution: {integrity: sha512-yKxviR5PH1OKNnisIzZKmgZSus0r2OZb8qCSbqmw34aolT4g3UlzYfeBRym+HJ1J471CR8e2ldNub4PubD1coA==}
 
+  '@humanfs/core@0.19.2':
+    resolution: {integrity: sha512-UhXNm+CFMWcbChXywFwkmhqjs3PRCmcSa/hfBgLIb7oQ5HNb1wS0icWsGtSAUNgefHeI+eBrA8I1fxmbHsGdvA==}
+    engines: {node: '>=18.18.0'}
+
+  '@humanfs/node@0.16.8':
+    resolution: {integrity: sha512-gE1eQNZ3R++kTzFUpdGlpmy8kDZD/MLyHqDwqjkVQI0JMdI1D51sy1H958PNXYkM2rAac7e5/CnIKZrHtPh3BQ==}
+    engines: {node: '>=18.18.0'}
+
+  '@humanfs/types@0.15.0':
+    resolution: {integrity: sha512-ZZ1w0aoQkwuUuC7Yf+7sdeaNfqQiiLcSRbfI08oAxqLtpXQr9AIVX7Ay7HLDuiLYAaFPu8oBYNq/QIi9URHJ3Q==}
+    engines: {node: '>=18.18.0'}
+
+  '@humanwhocodes/module-importer@1.0.1':
+    resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==}
+    engines: {node: '>=12.22'}
+
+  '@humanwhocodes/retry@0.4.3':
+    resolution: {integrity: sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==}
+    engines: {node: '>=18.18'}
+
   '@isaacs/cliui@9.0.0':
     resolution: {integrity: sha512-AokJm4tuBHillT+FpMtxQ60n8ObyXBatq7jD2/JA9dxbDDokKQm8KMht5ibGzLVU9IJDIKK4TPKgMHEYMn3lMg==}
     engines: {node: '>=18'}
@@ -630,9 +714,15 @@ packages:
   '@types/deep-eql@4.0.2':
     resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==}
 
+  '@types/esrecurse@4.3.1':
+    resolution: {integrity: sha512-xJBAbDifo5hpffDBuHl0Y8ywswbiAp/Wi7Y/GtAgSlZyIABppyurxVueOPE8LUQOxdlgi6Zqce7uoEpqNTeiUw==}
+
   '@types/estree@1.0.9':
     resolution: {integrity: sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==}
 
+  '@types/json-schema@7.0.15':
+    resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==}
+
   '@types/node@22.20.1':
     resolution: {integrity: sha512-EANqOCF9QFyra+4pfxUcX9STKJpCLjMbObVzljIJomAWSnuSIEAvyzEU53GaajbXJEgdh0iEcPL+DGvpUd4k1Q==}
 
@@ -642,6 +732,65 @@ packages:
   '@types/ws@8.18.1':
     resolution: {integrity: sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==}
 
+  '@typescript-eslint/eslint-plugin@8.63.0':
+    resolution: {integrity: sha512-rvwSgqT+DHpWdzfSzPatRLm02a0GlESt++9iy3hLCDY4BgkaLcl8LBi9Yh7XGFBpwcBE/K3024QuXWTpbz4FfQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      '@typescript-eslint/parser': ^8.63.0
+      eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+      typescript: '>=4.8.4 <6.1.0'
+
+  '@typescript-eslint/parser@8.63.0':
+    resolution: {integrity: sha512-gwh4gvvlaVDKKxyfxMG+Gnu1u9X0OQBwyGLkbwB65dIzBKnxeRiJlNFqlI3zwVhNXJIs6qV7mlFCn/BIajlVig==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+      typescript: '>=4.8.4 <6.1.0'
+
+  '@typescript-eslint/project-service@8.63.0':
+    resolution: {integrity: sha512-e5dh0/UI0ok53AlZ5wRkXCB32z/f2jUZqPR/ygAw5WYaSw8j9EoJWlS7wQjr/dmOaqWjnPIn2m+HhVPCMWGZVQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      typescript: '>=4.8.4 <6.1.0'
+
+  '@typescript-eslint/scope-manager@8.63.0':
+    resolution: {integrity: sha512-uUyfMWCnDSN8bCpcrY8nGP2BLkQ9Xn0GsipcONcpIDWhwhO4ZSyHvyS14U3X75mzxWxL3I2UZIrenTzdzcJO8A==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@typescript-eslint/tsconfig-utils@8.63.0':
+    resolution: {integrity: sha512-sUAbkulqBAsncKnbRP3+7CtQFRKicexnj7ZwNC6ddCR7EmrXvjvdCYMJbUIqMd6lwoEriZjwLo08aS5tSjVMHg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      typescript: '>=4.8.4 <6.1.0'
+
+  '@typescript-eslint/type-utils@8.63.0':
+    resolution: {integrity: sha512-Nzzh/OGxVCOjObjaj1CQF2RUasyYy2Jfuh+zZ3PjLzG2fYRriAiZLib9UKtO+CpQAS3YHiAS+ckZDclwqI1TPA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+      typescript: '>=4.8.4 <6.1.0'
+
+  '@typescript-eslint/types@8.63.0':
+    resolution: {integrity: sha512-xyLtl9DUBBFrcJS4x2pIqGLH68/tC2uOa4Z7pUteW09D3bXnnXUom4dyPikzWgB7llmIc1zoeI3aoUdC4rPK/Q==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@typescript-eslint/typescript-estree@8.63.0':
+    resolution: {integrity: sha512-ygBkU+B7ex5UI/gKhaqexWev79uISfIv7XQCRNYO/jmD8rGLPyWLAb3KMRT6nd8Gt9bmUBi9+iX6tBdYfOY81Q==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      typescript: '>=4.8.4 <6.1.0'
+
+  '@typescript-eslint/utils@8.63.0':
+    resolution: {integrity: sha512-fUKaeAvrTuQg/Tgt3nliAUSZHJM6DlCcfyEmxCvlX8kieWSStBX+5O5Fnidtc3i2JrH+9c/GL4RY2iasd/GPTA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+      typescript: '>=4.8.4 <6.1.0'
+
+  '@typescript-eslint/visitor-keys@8.63.0':
+    resolution: {integrity: sha512-UexrHGnGTpbuQHct2ExOc2ZcFbGUS9FOesCxxqdBGcpI1BxYu/LZ6U8Aq6/72XtF/qRBk9nhuGHFJIXXMhPMdw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
   '@vitest/expect@3.2.7':
     resolution: {integrity: sha512-E8eBXaKibuvH2pSZErOjdVb5vF4PbKYcrnluBTYxEk1l/VhhwZg1kZQsdtjq+CsF5CFydf2Rdkz7jDHKSisi3w==}
 
@@ -674,6 +823,11 @@ packages:
   abstract-logging@2.0.1:
     resolution: {integrity: sha512-2BjRTZxTPvheOvGbBslFSYOUkr+SjPtOnrLP33f+VIWLzezQpZcqVg7ja3L4dBXmzzgwT+a029jRx5PCi3JuiA==}
 
+  acorn-jsx@5.3.2:
+    resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
+    peerDependencies:
+      acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
+
   acorn@8.17.0:
     resolution: {integrity: sha512-xRQbDb9BnwDafYNn6Vwl839DYVjqXYb1XVGtWAZ1kcDc6iwAL4hg3B1dZlRiuENFeO2H53gFG3in621AdERVAg==}
     engines: {node: '>=0.4.0'}
@@ -687,6 +841,9 @@ packages:
       ajv:
         optional: true
 
+  ajv@6.15.0:
+    resolution: {integrity: sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==}
+
   ajv@8.20.0:
     resolution: {integrity: sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==}
 
@@ -768,6 +925,11 @@ packages:
     resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==}
     engines: {node: '>= 8'}
 
+  cssesc@3.0.0:
+    resolution: {integrity: sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==}
+    engines: {node: '>=4'}
+    hasBin: true
+
   debug@4.4.3:
     resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}
     engines: {node: '>=6.0'}
@@ -789,6 +951,9 @@ packages:
     resolution: {integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==}
     engines: {node: '>=4.0.0'}
 
+  deep-is@0.1.4:
+    resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==}
+
   deepmerge@4.3.1:
     resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==}
     engines: {node: '>=0.10.0'}
@@ -830,9 +995,71 @@ packages:
   escape-html@1.0.3:
     resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==}
 
+  escape-string-regexp@4.0.0:
+    resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==}
+    engines: {node: '>=10'}
+
+  eslint-config-prettier@10.1.8:
+    resolution: {integrity: sha512-82GZUjRS0p/jganf6q1rEO25VSoHH0hKPCTrgillPjdI/3bgBhAE1QzHrHTizjpRvy6pGAvKjDJtk2pF9NDq8w==}
+    hasBin: true
+    peerDependencies:
+      eslint: '>=7.0.0'
+
+  eslint-plugin-svelte@3.20.0:
+    resolution: {integrity: sha512-AElKLVt7Hjy4d7ljwhrhw9hux60DCxCNkmK8cY/aAXvjs8tpR7PvU4DlyI/SA1PaJww1gh0wPGo2pbyURuEwxQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.57.1 || ^9.0.0 || ^10.0.0
+      svelte: ^3.37.0 || ^4.0.0 || ^5.0.0
+    peerDependenciesMeta:
+      svelte:
+        optional: true
+
+  eslint-scope@8.4.0:
+    resolution: {integrity: sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  eslint-scope@9.1.2:
+    resolution: {integrity: sha512-xS90H51cKw0jltxmvmHy2Iai1LIqrfbw57b79w/J7MfvDfkIkFZ+kj6zC3BjtUwh150HsSSdxXZcsuv72miDFQ==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  eslint-visitor-keys@3.4.3:
+    resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+
+  eslint-visitor-keys@4.2.1:
+    resolution: {integrity: sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  eslint-visitor-keys@5.0.1:
+    resolution: {integrity: sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  eslint@10.6.0:
+    resolution: {integrity: sha512-6lVbcqSodALYo+4ELD0heG6lFiFxnLMuLkiMi2qV8LMp54N8tE8FT1GMH+ev4Ti00nFjNze2+Su6DsV5OQW3Dg==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+    hasBin: true
+    peerDependencies:
+      jiti: '*'
+    peerDependenciesMeta:
+      jiti:
+        optional: true
+
   esm-env@1.2.2:
     resolution: {integrity: sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA==}
 
+  espree@10.4.0:
+    resolution: {integrity: sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  espree@11.2.0:
+    resolution: {integrity: sha512-7p3DrVEIopW1B1avAGLuCSh1jubc01H2JHc8B4qqGblmg5gI9yumBgACjWo4JlIc04ufug4xJ3SQI8HkS/Rgzw==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  esquery@1.7.0:
+    resolution: {integrity: sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==}
+    engines: {node: '>=0.10'}
+
   esrap@2.2.13:
     resolution: {integrity: sha512-m8jH5hZgJE2RRUK/jjkGPcJEDAV+dYnZYFkosQaPTcE+Yw4xynXHOo6FUdwaWBtdR3b1MMa7wEDTSHeR2VWsGA==}
     peerDependencies:
@@ -841,9 +1068,21 @@ packages:
       '@typescript-eslint/types':
         optional: true
 
+  esrecurse@4.3.0:
+    resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==}
+    engines: {node: '>=4.0'}
+
+  estraverse@5.3.0:
+    resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==}
+    engines: {node: '>=4.0'}
+
   estree-walker@3.0.3:
     resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==}
 
+  esutils@2.0.3:
+    resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==}
+    engines: {node: '>=0.10.0'}
+
   expand-template@2.0.3:
     resolution: {integrity: sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==}
     engines: {node: '>=6'}
@@ -858,9 +1097,15 @@ packages:
   fast-deep-equal@3.1.3:
     resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
 
+  fast-json-stable-stringify@2.1.0:
+    resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==}
+
   fast-json-stringify@7.0.0:
     resolution: {integrity: sha512-YV53BAbR3Qwq37wfD1oZ97YJ0nYj6CwfzKXQ38ock9XxI2EnLOdl5psKms6Evook6ACckytZJOaKY0ThmIi1uw==}
 
+  fast-levenshtein@2.0.6:
+    resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==}
+
   fast-querystring@1.1.2:
     resolution: {integrity: sha512-g6KuKWmFXc0fID8WWH0jit4g0AGBoJhCkJMb1RmbsSEUNvQ+ZC8D6CUZ+GtF8nMzSPXnhiePyyqqipzNNEnHjg==}
 
@@ -885,6 +1130,10 @@ packages:
       picomatch:
         optional: true
 
+  file-entry-cache@8.0.0:
+    resolution: {integrity: sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==}
+    engines: {node: '>=16.0.0'}
+
   file-uri-to-path@1.0.0:
     resolution: {integrity: sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==}
 
@@ -892,6 +1141,17 @@ packages:
     resolution: {integrity: sha512-Zf4Xve4RymLl7NgaavNebZ01joJ8MfVerOG43wy7SHLO+r+K0C6d/SE0BiR7AV5V1VOCFlOP7ecdo+I4qmiHrQ==}
     engines: {node: '>=20'}
 
+  find-up@5.0.0:
+    resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==}
+    engines: {node: '>=10'}
+
+  flat-cache@4.0.1:
+    resolution: {integrity: sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==}
+    engines: {node: '>=16'}
+
+  flatted@3.4.2:
+    resolution: {integrity: sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==}
+
   foreground-child@3.3.1:
     resolution: {integrity: sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==}
     engines: {node: '>=14'}
@@ -907,12 +1167,24 @@ packages:
   github-from-package@0.0.0:
     resolution: {integrity: sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==}
 
+  glob-parent@6.0.2:
+    resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==}
+    engines: {node: '>=10.13.0'}
+
   glob@11.1.0:
     resolution: {integrity: sha512-vuNwKSaKiqm7g0THUBu2x7ckSs3XJLXE+2ssL7/MfTGPLLcrJQ/4Uq1CjPTtO5cCIiRxqvN6Twy1qOwhL0Xjcw==}
     engines: {node: 20 || >=22}
     deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
     hasBin: true
 
+  globals@16.5.0:
+    resolution: {integrity: sha512-c/c15i26VrJ4IRt5Z89DnIzCGDn9EcebibhAOjw5ibqEHsE1wLUgkPn9RDmNcUKyU87GeaL633nyJ+pplFR2ZQ==}
+    engines: {node: '>=18'}
+
+  globals@17.7.0:
+    resolution: {integrity: sha512-Czmyns5dUsq4seFBR/Kdydhmo8y9kC79hiSkPn0YcGtNnYWnrgt0vjrSjx9tspoDGWm2CMarffRuLjM4xUz8xg==}
+    engines: {node: '>=18'}
+
   highlight.js@11.11.1:
     resolution: {integrity: sha512-Xwwo44whKBVCYoliBQwaPvtd/2tYFkRQtXDWj1nackaV2JPXx3L0+Jvd8/qCJ2p+ML0/XVkJ2q+Mr+UVdpJK5w==}
     engines: {node: '>=12.0.0'}
@@ -924,6 +1196,18 @@ packages:
   ieee754@1.2.1:
     resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==}
 
+  ignore@5.3.2:
+    resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==}
+    engines: {node: '>= 4'}
+
+  ignore@7.0.5:
+    resolution: {integrity: sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==}
+    engines: {node: '>= 4'}
+
+  imurmurhash@0.1.4:
+    resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==}
+    engines: {node: '>=0.8.19'}
+
   inherits@2.0.4:
     resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
 
@@ -934,6 +1218,14 @@ packages:
     resolution: {integrity: sha512-9VGk3HGanVE6JoZXHiCpnGy5X0jYDnN4EA4lntFPj+1vIWlFhIylq2CrrCOJH9EAhc5CYhq18F2Av2tgoAPsYQ==}
     engines: {node: '>= 10'}
 
+  is-extglob@2.1.1:
+    resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
+    engines: {node: '>=0.10.0'}
+
+  is-glob@4.0.3:
+    resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
+    engines: {node: '>=0.10.0'}
+
   is-reference@3.0.3:
     resolution: {integrity: sha512-ixkJoqQvAP88E6wLydLGGqCJsrFUnqoH6HnaczB8XmDH1oaWU+xxdptvikTgaEhtZ53Ky6YXiBuUI2WXLMCwjw==}
 
@@ -947,22 +1239,49 @@ packages:
   js-tokens@9.0.1:
     resolution: {integrity: sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==}
 
+  json-buffer@3.0.1:
+    resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==}
+
   json-schema-ref-resolver@3.0.0:
     resolution: {integrity: sha512-hOrZIVL5jyYFjzk7+y7n5JDzGlU8rfWDuYyHwGa2WA8/pcmMHezp2xsVwxrebD/Q9t8Nc5DboieySDpCp4WG4A==}
 
+  json-schema-traverse@0.4.1:
+    resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==}
+
   json-schema-traverse@1.0.0:
     resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==}
 
+  json-stable-stringify-without-jsonify@1.0.1:
+    resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==}
+
+  keyv@4.5.4:
+    resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==}
+
   kleur@4.1.5:
     resolution: {integrity: sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==}
     engines: {node: '>=6'}
 
+  known-css-properties@0.37.0:
+    resolution: {integrity: sha512-JCDrsP4Z1Sb9JwG0aJ8Eo2r7k4Ou5MwmThS/6lcIe1ICyb7UBJKGRIUUdqc2ASdE/42lgz6zFUnzAIhtXnBVrQ==}
+
+  levn@0.4.1:
+    resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==}
+    engines: {node: '>= 0.8.0'}
+
   light-my-request@6.6.0:
     resolution: {integrity: sha512-CHYbu8RtboSIoVsHZ6Ye4cj4Aw/yg2oAFimlF7mNvfDV192LR7nDiKtSIfCuLT7KokPSTn/9kfVLm5OGN0A28A==}
 
+  lilconfig@2.1.0:
+    resolution: {integrity: sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==}
+    engines: {node: '>=10'}
+
   locate-character@3.0.0:
     resolution: {integrity: sha512-SW13ws7BjaeJ6p7Q6CO2nchbYEc3X3J6WrmTTDto7yMPqVSZTUyY5Tjbid+Ab8gLnATtygYtiDIJGQRRn2ZOiA==}
 
+  locate-path@6.0.0:
+    resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==}
+    engines: {node: '>=10'}
+
   loupe@3.2.1:
     resolution: {integrity: sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==}
 
@@ -1021,6 +1340,9 @@ packages:
   napi-build-utils@2.0.0:
     resolution: {integrity: sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA==}
 
+  natural-compare@1.4.0:
+    resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==}
+
   node-abi@3.94.0:
     resolution: {integrity: sha512-W5ZNO5KRPB5TkYmGVD9F6YqhsglXJzE6etpbmT+f6EQElhiX/UTG551cnsRGvLG3fyZEg9HwaDmNmj5nwJ4z9g==}
     engines: {node: '>=10'}
@@ -1032,9 +1354,25 @@ packages:
   once@1.4.0:
     resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==}
 
+  optionator@0.9.4:
+    resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==}
+    engines: {node: '>= 0.8.0'}
+
+  p-limit@3.1.0:
+    resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==}
+    engines: {node: '>=10'}
+
+  p-locate@5.0.0:
+    resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==}
+    engines: {node: '>=10'}
+
   package-json-from-dist@1.0.1:
     resolution: {integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==}
 
+  path-exists@4.0.0:
+    resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==}
+    engines: {node: '>=8'}
+
   path-key@3.1.1:
     resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==}
     engines: {node: '>=8'}
@@ -1067,6 +1405,34 @@ packages:
     resolution: {integrity: sha512-r34yH/GlQpKZbU1BvFFqOjhISRo1MNx1tWYsYvmj6KIRHSPMT2+yHOEb1SG6NMvRoHRF0a07kCOox/9yakl1vg==}
     hasBin: true
 
+  postcss-load-config@3.1.4:
+    resolution: {integrity: sha512-6DiM4E7v4coTE4uzA8U//WhtPwyhiim3eyjEMFCnUpzbrkK9wJHgKDT2mR+HbtSrd/NubVaYTOpSpjUl8NQeRg==}
+    engines: {node: '>= 10'}
+    peerDependencies:
+      postcss: '>=8.0.9'
+      ts-node: '>=9.0.0'
+    peerDependenciesMeta:
+      postcss:
+        optional: true
+      ts-node:
+        optional: true
+
+  postcss-safe-parser@7.0.1:
+    resolution: {integrity: sha512-0AioNCJZ2DPYz5ABT6bddIqlhgwhpHZ/l65YAYo0BCIn0xiDpsnTHz0gnoTGk0OXZW0JRs+cDwL8u/teRdz+8A==}
+    engines: {node: '>=18.0'}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-scss@4.0.9:
+    resolution: {integrity: sha512-AjKOeiwAitL/MXxQW2DliT28EKukvvbEWx3LBmJIRN8KfBGZbRTxNYW0kSqi1COiTZ57nZ9NW06S6ux//N1c9A==}
+    engines: {node: '>=12.0'}
+    peerDependencies:
+      postcss: ^8.4.29
+
+  postcss-selector-parser@7.1.4:
+    resolution: {integrity: sha512-HeP7D2wyhkR+XaK6v4W8oRF62Dsz4flyuczALJp61GckGm42u1saSSJ/0auvcBqxs3jMRFEcPK34At/0JBKdOg==}
+    engines: {node: '>=4'}
+
   postcss@8.5.16:
     resolution: {integrity: sha512-vuwillviilfKZsg0VGj5R/YwwcHx4SLsIOI/7K6mQkWx+l5cUHTjj5g0AasTBcyXsbfTgrwsUNmVUb5xVwyPwg==}
     engines: {node: ^10 || ^12 || >=14}
@@ -1077,6 +1443,22 @@ packages:
     deprecated: No longer maintained. Please contact the author of the relevant native addon; alternatives are available.
     hasBin: true
 
+  prelude-ls@1.2.1:
+    resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==}
+    engines: {node: '>= 0.8.0'}
+
+  prettier-plugin-svelte@4.1.1:
+    resolution: {integrity: sha512-wXvbXMjSvb4C9ENWTHXyd+ihakKCsJ6rJhLP6/8HFNj4GkZr48jqL9PoKsl2sk7SyCZRTnJ7O2TTowUpOxP/KA==}
+    engines: {node: '>=20'}
+    peerDependencies:
+      prettier: ^3.0.0
+      svelte: ^5.0.0
+
+  prettier@3.9.4:
+    resolution: {integrity: sha512-yWG/o/4oJfo036EKAfK6ACAoDOfHeRHx4tuxkfBZiauURiaSmYwlpOr5LQqKtIkRD2z1PLteme2WoxEnj4tHTg==}
+    engines: {node: '>=14'}
+    hasBin: true
+
   process-warning@4.0.1:
     resolution: {integrity: sha512-3c2LzQ3rY9d0hc1emcsHhfT9Jwz0cChib/QN89oME2R451w5fy3f0afAhERFZAwrbDU43wk12d0ORBpDVME50Q==}
 
@@ -1086,6 +1468,10 @@ packages:
   pump@3.0.4:
     resolution: {integrity: sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==}
 
+  punycode@2.3.1:
+    resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==}
+    engines: {node: '>=6'}
+
   quick-format-unescaped@4.0.4:
     resolution: {integrity: sha512-tYC1Q1hgyRuHgloV/YXs2w15unPVh8qfu/qCTfhTYamaw7fyhumKa2yGpdSo87vY32rIclj+4fWYQXUMs9EHvg==}
 
@@ -1217,6 +1603,15 @@ packages:
       svelte: ^4.0.0 || ^5.0.0-next.0
       typescript: '>=5.0.0'
 
+  svelte-eslint-parser@1.8.0:
+    resolution: {integrity: sha512-mikR1qwIVy3t5WthUoAXkMwxkXvabZP9FJgdx35Ei7EbGWmctva1Pih16Koeor/bdNNq8NXHlwKGS6NkYTawLg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0, pnpm: 10.34.1}
+    peerDependencies:
+      svelte: ^3.37.0 || ^4.0.0 || ^5.0.0
+    peerDependenciesMeta:
+      svelte:
+        optional: true
+
   svelte@5.56.4:
     resolution: {integrity: sha512-/d0QHehmRuJW8gVz395MTkPcPozxzdjBMBE8oEYGz8O3b9KTMzzQ9ZHJQLuFKOHOPQbU6kx/X4iid/EBBzH7iw==}
     engines: {node: '>=18'}
@@ -1262,6 +1657,12 @@ packages:
     resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==}
     engines: {node: '>=0.6'}
 
+  ts-api-utils@2.5.0:
+    resolution: {integrity: sha512-OJ/ibxhPlqrMM0UiNHJ/0CKQkoKF243/AEmplt3qpRgkW8VG7IfOS41h7V8TjITqdByHzrjcS/2si+y4lIh8NA==}
+    engines: {node: '>=18.12'}
+    peerDependencies:
+      typescript: '>=4.8.4'
+
   tsx@4.23.0:
     resolution: {integrity: sha512-eUdUIaCr963q2h5u3+QwvYp0+eqPvn+egeqZUm0hwERCqqx1E3kK5ehbGCvqSE5MQAULr67ww0cA3jKc3YkM1w==}
     engines: {node: '>=18.0.0'}
@@ -1270,6 +1671,17 @@ packages:
   tunnel-agent@0.6.0:
     resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==}
 
+  type-check@0.4.0:
+    resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==}
+    engines: {node: '>= 0.8.0'}
+
+  typescript-eslint@8.63.0:
+    resolution: {integrity: sha512-xgwXyzG4sK9ALkBxbyGkTMMOS+imnW65iPhxCQMK83KhxyoDNW7l+IDqEf9vMdoUidHpOoS967RCq4eMiTexwQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+      typescript: '>=4.8.4 <6.1.0'
+
   typescript@5.9.3:
     resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
     engines: {node: '>=14.17'}
@@ -1278,6 +1690,9 @@ packages:
   undici-types@6.21.0:
     resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==}
 
+  uri-js@4.4.1:
+    resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==}
+
   util-deprecate@1.0.2:
     resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==}
 
@@ -1412,6 +1827,10 @@ packages:
     engines: {node: '>=8'}
     hasBin: true
 
+  word-wrap@1.2.5:
+    resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==}
+    engines: {node: '>=0.10.0'}
+
   wrappy@1.0.2:
     resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==}
 
@@ -1427,6 +1846,14 @@ packages:
       utf-8-validate:
         optional: true
 
+  yaml@1.10.3:
+    resolution: {integrity: sha512-vIYeF1u3CjlhAFekPPAk2h/Kv4T3mAkMox5OymRiJQB0spDP10LHvt+K7G9Ny6NuuMAb25/6n1qyUjAcGNf/AA==}
+    engines: {node: '>= 6'}
+
+  yocto-queue@0.1.0:
+    resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==}
+    engines: {node: '>=10'}
+
   zimmerframe@1.1.4:
     resolution: {integrity: sha512-B58NGBEoc8Y9MWWCQGl/gq9xBCe4IiKM0a2x7GZdQKOW5Exr8S1W24J6OgM1njK8xCRGvAJIL/MxXHf6SkmQKQ==}
 
@@ -1588,6 +2015,40 @@ snapshots:
   '@esbuild/win32-x64@0.28.1':
     optional: true
 
+  '@eslint-community/eslint-utils@4.9.1(eslint@10.6.0)':
+    dependencies:
+      eslint: 10.6.0
+      eslint-visitor-keys: 3.4.3
+
+  '@eslint-community/regexpp@4.12.2': {}
+
+  '@eslint/config-array@0.23.5':
+    dependencies:
+      '@eslint/object-schema': 3.0.5
+      debug: 4.4.3
+      minimatch: 10.2.5
+    transitivePeerDependencies:
+      - supports-color
+
+  '@eslint/config-helpers@0.6.0':
+    dependencies:
+      '@eslint/core': 1.2.1
+
+  '@eslint/core@1.2.1':
+    dependencies:
+      '@types/json-schema': 7.0.15
+
+  '@eslint/js@10.0.1(eslint@10.6.0)':
+    optionalDependencies:
+      eslint: 10.6.0
+
+  '@eslint/object-schema@3.0.5': {}
+
+  '@eslint/plugin-kit@0.7.2':
+    dependencies:
+      '@eslint/core': 1.2.1
+      levn: 0.4.1
+
   '@fastify/accept-negotiator@2.0.1': {}
 
   '@fastify/ajv-compiler@4.0.5':
@@ -1630,6 +2091,22 @@ snapshots:
       fastq: 1.20.1
       glob: 11.1.0
 
+  '@humanfs/core@0.19.2':
+    dependencies:
+      '@humanfs/types': 0.15.0
+
+  '@humanfs/node@0.16.8':
+    dependencies:
+      '@humanfs/core': 0.19.2
+      '@humanfs/types': 0.15.0
+      '@humanwhocodes/retry': 0.4.3
+
+  '@humanfs/types@0.15.0': {}
+
+  '@humanwhocodes/module-importer@1.0.1': {}
+
+  '@humanwhocodes/retry@0.4.3': {}
+
   '@isaacs/cliui@9.0.0': {}
 
   '@jridgewell/gen-mapping@0.3.13':
@@ -1736,23 +2213,23 @@ snapshots:
 
   '@sveltejs/load-config@0.2.0': {}
 
-  '@sveltejs/vite-plugin-svelte-inspector@4.0.1(@sveltejs/vite-plugin-svelte@5.1.1(svelte@5.56.4)(vite@6.4.3(@types/node@22.20.1)(tsx@4.23.0)))(svelte@5.56.4)(vite@6.4.3(@types/node@22.20.1)(tsx@4.23.0))':
+  '@sveltejs/vite-plugin-svelte-inspector@4.0.1(@sveltejs/vite-plugin-svelte@5.1.1(svelte@5.56.4(@typescript-eslint/types@8.63.0))(vite@6.4.3(@types/node@22.20.1)(tsx@4.23.0)))(svelte@5.56.4(@typescript-eslint/types@8.63.0))(vite@6.4.3(@types/node@22.20.1)(tsx@4.23.0))':
     dependencies:
-      '@sveltejs/vite-plugin-svelte': 5.1.1(svelte@5.56.4)(vite@6.4.3(@types/node@22.20.1)(tsx@4.23.0))
+      '@sveltejs/vite-plugin-svelte': 5.1.1(svelte@5.56.4(@typescript-eslint/types@8.63.0))(vite@6.4.3(@types/node@22.20.1)(tsx@4.23.0))
       debug: 4.4.3
-      svelte: 5.56.4
+      svelte: 5.56.4(@typescript-eslint/types@8.63.0)
       vite: 6.4.3(@types/node@22.20.1)(tsx@4.23.0)
     transitivePeerDependencies:
       - supports-color
 
-  '@sveltejs/vite-plugin-svelte@5.1.1(svelte@5.56.4)(vite@6.4.3(@types/node@22.20.1)(tsx@4.23.0))':
+  '@sveltejs/vite-plugin-svelte@5.1.1(svelte@5.56.4(@typescript-eslint/types@8.63.0))(vite@6.4.3(@types/node@22.20.1)(tsx@4.23.0))':
     dependencies:
-      '@sveltejs/vite-plugin-svelte-inspector': 4.0.1(@sveltejs/vite-plugin-svelte@5.1.1(svelte@5.56.4)(vite@6.4.3(@types/node@22.20.1)(tsx@4.23.0)))(svelte@5.56.4)(vite@6.4.3(@types/node@22.20.1)(tsx@4.23.0))
+      '@sveltejs/vite-plugin-svelte-inspector': 4.0.1(@sveltejs/vite-plugin-svelte@5.1.1(svelte@5.56.4(@typescript-eslint/types@8.63.0))(vite@6.4.3(@types/node@22.20.1)(tsx@4.23.0)))(svelte@5.56.4(@typescript-eslint/types@8.63.0))(vite@6.4.3(@types/node@22.20.1)(tsx@4.23.0))
       debug: 4.4.3
       deepmerge: 4.3.1
       kleur: 4.1.5
       magic-string: 0.30.21
-      svelte: 5.56.4
+      svelte: 5.56.4(@typescript-eslint/types@8.63.0)
       vite: 6.4.3(@types/node@22.20.1)(tsx@4.23.0)
       vitefu: 1.1.3(vite@6.4.3(@types/node@22.20.1)(tsx@4.23.0))
     transitivePeerDependencies:
@@ -1771,8 +2248,12 @@ snapshots:
 
   '@types/deep-eql@4.0.2': {}
 
+  '@types/esrecurse@4.3.1': {}
+
   '@types/estree@1.0.9': {}
 
+  '@types/json-schema@7.0.15': {}
+
   '@types/node@22.20.1':
     dependencies:
       undici-types: 6.21.0
@@ -1783,6 +2264,97 @@ snapshots:
     dependencies:
       '@types/node': 22.20.1
 
+  '@typescript-eslint/eslint-plugin@8.63.0(@typescript-eslint/parser@8.63.0(eslint@10.6.0)(typescript@5.9.3))(eslint@10.6.0)(typescript@5.9.3)':
+    dependencies:
+      '@eslint-community/regexpp': 4.12.2
+      '@typescript-eslint/parser': 8.63.0(eslint@10.6.0)(typescript@5.9.3)
+      '@typescript-eslint/scope-manager': 8.63.0
+      '@typescript-eslint/type-utils': 8.63.0(eslint@10.6.0)(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.63.0(eslint@10.6.0)(typescript@5.9.3)
+      '@typescript-eslint/visitor-keys': 8.63.0
+      eslint: 10.6.0
+      ignore: 7.0.5
+      natural-compare: 1.4.0
+      ts-api-utils: 2.5.0(typescript@5.9.3)
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/parser@8.63.0(eslint@10.6.0)(typescript@5.9.3)':
+    dependencies:
+      '@typescript-eslint/scope-manager': 8.63.0
+      '@typescript-eslint/types': 8.63.0
+      '@typescript-eslint/typescript-estree': 8.63.0(typescript@5.9.3)
+      '@typescript-eslint/visitor-keys': 8.63.0
+      debug: 4.4.3
+      eslint: 10.6.0
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/project-service@8.63.0(typescript@5.9.3)':
+    dependencies:
+      '@typescript-eslint/tsconfig-utils': 8.63.0(typescript@5.9.3)
+      '@typescript-eslint/types': 8.63.0
+      debug: 4.4.3
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/scope-manager@8.63.0':
+    dependencies:
+      '@typescript-eslint/types': 8.63.0
+      '@typescript-eslint/visitor-keys': 8.63.0
+
+  '@typescript-eslint/tsconfig-utils@8.63.0(typescript@5.9.3)':
+    dependencies:
+      typescript: 5.9.3
+
+  '@typescript-eslint/type-utils@8.63.0(eslint@10.6.0)(typescript@5.9.3)':
+    dependencies:
+      '@typescript-eslint/types': 8.63.0
+      '@typescript-eslint/typescript-estree': 8.63.0(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.63.0(eslint@10.6.0)(typescript@5.9.3)
+      debug: 4.4.3
+      eslint: 10.6.0
+      ts-api-utils: 2.5.0(typescript@5.9.3)
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/types@8.63.0': {}
+
+  '@typescript-eslint/typescript-estree@8.63.0(typescript@5.9.3)':
+    dependencies:
+      '@typescript-eslint/project-service': 8.63.0(typescript@5.9.3)
+      '@typescript-eslint/tsconfig-utils': 8.63.0(typescript@5.9.3)
+      '@typescript-eslint/types': 8.63.0
+      '@typescript-eslint/visitor-keys': 8.63.0
+      debug: 4.4.3
+      minimatch: 10.2.5
+      semver: 7.8.5
+      tinyglobby: 0.2.17
+      ts-api-utils: 2.5.0(typescript@5.9.3)
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/utils@8.63.0(eslint@10.6.0)(typescript@5.9.3)':
+    dependencies:
+      '@eslint-community/eslint-utils': 4.9.1(eslint@10.6.0)
+      '@typescript-eslint/scope-manager': 8.63.0
+      '@typescript-eslint/types': 8.63.0
+      '@typescript-eslint/typescript-estree': 8.63.0(typescript@5.9.3)
+      eslint: 10.6.0
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/visitor-keys@8.63.0':
+    dependencies:
+      '@typescript-eslint/types': 8.63.0
+      eslint-visitor-keys: 5.0.1
+
   '@vitest/expect@3.2.7':
     dependencies:
       '@types/chai': 5.2.3
@@ -1827,12 +2399,23 @@ snapshots:
 
   abstract-logging@2.0.1: {}
 
+  acorn-jsx@5.3.2(acorn@8.17.0):
+    dependencies:
+      acorn: 8.17.0
+
   acorn@8.17.0: {}
 
   ajv-formats@3.0.1(ajv@8.20.0):
     optionalDependencies:
       ajv: 8.20.0
 
+  ajv@6.15.0:
+    dependencies:
+      fast-deep-equal: 3.1.3
+      fast-json-stable-stringify: 2.1.0
+      json-schema-traverse: 0.4.1
+      uri-js: 4.4.1
+
   ajv@8.20.0:
     dependencies:
       fast-deep-equal: 3.1.3
@@ -1913,6 +2496,8 @@ snapshots:
       shebang-command: 2.0.0
       which: 2.0.2
 
+  cssesc@3.0.0: {}
+
   debug@4.4.3:
     dependencies:
       ms: 2.1.3
@@ -1925,6 +2510,8 @@ snapshots:
 
   deep-extend@0.6.0: {}
 
+  deep-is@0.1.4: {}
+
   deepmerge@4.3.1: {}
 
   depd@2.0.0: {}
@@ -2005,16 +2592,119 @@ snapshots:
 
   escape-html@1.0.3: {}
 
+  escape-string-regexp@4.0.0: {}
+
+  eslint-config-prettier@10.1.8(eslint@10.6.0):
+    dependencies:
+      eslint: 10.6.0
+
+  eslint-plugin-svelte@3.20.0(eslint@10.6.0)(svelte@5.56.4(@typescript-eslint/types@8.63.0)):
+    dependencies:
+      '@eslint-community/eslint-utils': 4.9.1(eslint@10.6.0)
+      '@jridgewell/sourcemap-codec': 1.5.5
+      eslint: 10.6.0
+      esutils: 2.0.3
+      globals: 16.5.0
+      known-css-properties: 0.37.0
+      postcss: 8.5.16
+      postcss-load-config: 3.1.4(postcss@8.5.16)
+      postcss-safe-parser: 7.0.1(postcss@8.5.16)
+      semver: 7.8.5
+      svelte-eslint-parser: 1.8.0(svelte@5.56.4(@typescript-eslint/types@8.63.0))
+    optionalDependencies:
+      svelte: 5.56.4(@typescript-eslint/types@8.63.0)
+    transitivePeerDependencies:
+      - ts-node
+
+  eslint-scope@8.4.0:
+    dependencies:
+      esrecurse: 4.3.0
+      estraverse: 5.3.0
+
+  eslint-scope@9.1.2:
+    dependencies:
+      '@types/esrecurse': 4.3.1
+      '@types/estree': 1.0.9
+      esrecurse: 4.3.0
+      estraverse: 5.3.0
+
+  eslint-visitor-keys@3.4.3: {}
+
+  eslint-visitor-keys@4.2.1: {}
+
+  eslint-visitor-keys@5.0.1: {}
+
+  eslint@10.6.0:
+    dependencies:
+      '@eslint-community/eslint-utils': 4.9.1(eslint@10.6.0)
+      '@eslint-community/regexpp': 4.12.2
+      '@eslint/config-array': 0.23.5
+      '@eslint/config-helpers': 0.6.0
+      '@eslint/core': 1.2.1
+      '@eslint/plugin-kit': 0.7.2
+      '@humanfs/node': 0.16.8
+      '@humanwhocodes/module-importer': 1.0.1
+      '@humanwhocodes/retry': 0.4.3
+      '@types/estree': 1.0.9
+      ajv: 6.15.0
+      cross-spawn: 7.0.6
+      debug: 4.4.3
+      escape-string-regexp: 4.0.0
+      eslint-scope: 9.1.2
+      eslint-visitor-keys: 5.0.1
+      espree: 11.2.0
+      esquery: 1.7.0
+      esutils: 2.0.3
+      fast-deep-equal: 3.1.3
+      file-entry-cache: 8.0.0
+      find-up: 5.0.0
+      glob-parent: 6.0.2
+      ignore: 5.3.2
+      imurmurhash: 0.1.4
+      is-glob: 4.0.3
+      json-stable-stringify-without-jsonify: 1.0.1
+      minimatch: 10.2.5
+      natural-compare: 1.4.0
+      optionator: 0.9.4
+    transitivePeerDependencies:
+      - supports-color
+
   esm-env@1.2.2: {}
 
-  esrap@2.2.13:
+  espree@10.4.0:
+    dependencies:
+      acorn: 8.17.0
+      acorn-jsx: 5.3.2(acorn@8.17.0)
+      eslint-visitor-keys: 4.2.1
+
+  espree@11.2.0:
+    dependencies:
+      acorn: 8.17.0
+      acorn-jsx: 5.3.2(acorn@8.17.0)
+      eslint-visitor-keys: 5.0.1
+
+  esquery@1.7.0:
+    dependencies:
+      estraverse: 5.3.0
+
+  esrap@2.2.13(@typescript-eslint/types@8.63.0):
     dependencies:
       '@jridgewell/sourcemap-codec': 1.5.5
+    optionalDependencies:
+      '@typescript-eslint/types': 8.63.0
+
+  esrecurse@4.3.0:
+    dependencies:
+      estraverse: 5.3.0
+
+  estraverse@5.3.0: {}
 
   estree-walker@3.0.3:
     dependencies:
       '@types/estree': 1.0.9
 
+  esutils@2.0.3: {}
+
   expand-template@2.0.3: {}
 
   expect-type@1.4.0: {}
@@ -2023,6 +2713,8 @@ snapshots:
 
   fast-deep-equal@3.1.3: {}
 
+  fast-json-stable-stringify@2.1.0: {}
+
   fast-json-stringify@7.0.0:
     dependencies:
       '@fastify/merge-json-schemas': 0.2.1
@@ -2032,6 +2724,8 @@ snapshots:
       json-schema-ref-resolver: 3.0.0
       rfdc: 1.4.1
 
+  fast-levenshtein@2.0.6: {}
+
   fast-querystring@1.1.2:
     dependencies:
       fast-decode-uri-component: 1.0.1
@@ -2066,6 +2760,10 @@ snapshots:
     optionalDependencies:
       picomatch: 4.0.5
 
+  file-entry-cache@8.0.0:
+    dependencies:
+      flat-cache: 4.0.1
+
   file-uri-to-path@1.0.0: {}
 
   find-my-way@9.6.0:
@@ -2074,6 +2772,18 @@ snapshots:
       fast-querystring: 1.1.2
       safe-regex2: 5.1.1
 
+  find-up@5.0.0:
+    dependencies:
+      locate-path: 6.0.0
+      path-exists: 4.0.0
+
+  flat-cache@4.0.1:
+    dependencies:
+      flatted: 3.4.2
+      keyv: 4.5.4
+
+  flatted@3.4.2: {}
+
   foreground-child@3.3.1:
     dependencies:
       cross-spawn: 7.0.6
@@ -2086,6 +2796,10 @@ snapshots:
 
   github-from-package@0.0.0: {}
 
+  glob-parent@6.0.2:
+    dependencies:
+      is-glob: 4.0.3
+
   glob@11.1.0:
     dependencies:
       foreground-child: 3.3.1
@@ -2095,6 +2809,10 @@ snapshots:
       package-json-from-dist: 1.0.1
       path-scurry: 2.0.2
 
+  globals@16.5.0: {}
+
+  globals@17.7.0: {}
+
   highlight.js@11.11.1: {}
 
   http-errors@2.0.1:
@@ -2107,12 +2825,24 @@ snapshots:
 
   ieee754@1.2.1: {}
 
+  ignore@5.3.2: {}
+
+  ignore@7.0.5: {}
+
+  imurmurhash@0.1.4: {}
+
   inherits@2.0.4: {}
 
   ini@1.3.8: {}
 
   ipaddr.js@2.4.0: {}
 
+  is-extglob@2.1.1: {}
+
+  is-glob@4.0.3:
+    dependencies:
+      is-extglob: 2.1.1
+
   is-reference@3.0.3:
     dependencies:
       '@types/estree': 1.0.9
@@ -2125,22 +2855,45 @@ snapshots:
 
   js-tokens@9.0.1: {}
 
+  json-buffer@3.0.1: {}
+
   json-schema-ref-resolver@3.0.0:
     dependencies:
       dequal: 2.0.3
 
+  json-schema-traverse@0.4.1: {}
+
   json-schema-traverse@1.0.0: {}
 
+  json-stable-stringify-without-jsonify@1.0.1: {}
+
+  keyv@4.5.4:
+    dependencies:
+      json-buffer: 3.0.1
+
   kleur@4.1.5: {}
 
+  known-css-properties@0.37.0: {}
+
+  levn@0.4.1:
+    dependencies:
+      prelude-ls: 1.2.1
+      type-check: 0.4.0
+
   light-my-request@6.6.0:
     dependencies:
       cookie: 1.1.1
       process-warning: 4.0.1
       set-cookie-parser: 2.7.2
 
+  lilconfig@2.1.0: {}
+
   locate-character@3.0.0: {}
 
+  locate-path@6.0.0:
+    dependencies:
+      p-locate: 5.0.0
+
   loupe@3.2.1: {}
 
   lru-cache@11.5.2: {}
@@ -2177,6 +2930,8 @@ snapshots:
 
   napi-build-utils@2.0.0: {}
 
+  natural-compare@1.4.0: {}
+
   node-abi@3.94.0:
     dependencies:
       semver: 7.8.5
@@ -2187,8 +2942,27 @@ snapshots:
     dependencies:
       wrappy: 1.0.2
 
+  optionator@0.9.4:
+    dependencies:
+      deep-is: 0.1.4
+      fast-levenshtein: 2.0.6
+      levn: 0.4.1
+      prelude-ls: 1.2.1
+      type-check: 0.4.0
+      word-wrap: 1.2.5
+
+  p-limit@3.1.0:
+    dependencies:
+      yocto-queue: 0.1.0
+
+  p-locate@5.0.0:
+    dependencies:
+      p-limit: 3.1.0
+
   package-json-from-dist@1.0.1: {}
 
+  path-exists@4.0.0: {}
+
   path-key@3.1.1: {}
 
   path-scurry@2.0.2:
@@ -2224,6 +2998,26 @@ snapshots:
       sonic-boom: 4.2.1
       thread-stream: 4.2.0
 
+  postcss-load-config@3.1.4(postcss@8.5.16):
+    dependencies:
+      lilconfig: 2.1.0
+      yaml: 1.10.3
+    optionalDependencies:
+      postcss: 8.5.16
+
+  postcss-safe-parser@7.0.1(postcss@8.5.16):
+    dependencies:
+      postcss: 8.5.16
+
+  postcss-scss@4.0.9(postcss@8.5.16):
+    dependencies:
+      postcss: 8.5.16
+
+  postcss-selector-parser@7.1.4:
+    dependencies:
+      cssesc: 3.0.0
+      util-deprecate: 1.0.2
+
   postcss@8.5.16:
     dependencies:
       nanoid: 3.3.15
@@ -2245,6 +3039,15 @@ snapshots:
       tar-fs: 2.1.5
       tunnel-agent: 0.6.0
 
+  prelude-ls@1.2.1: {}
+
+  prettier-plugin-svelte@4.1.1(prettier@3.9.4)(svelte@5.56.4(@typescript-eslint/types@8.63.0)):
+    dependencies:
+      prettier: 3.9.4
+      svelte: 5.56.4(@typescript-eslint/types@8.63.0)
+
+  prettier@3.9.4: {}
+
   process-warning@4.0.1: {}
 
   process-warning@5.0.0: {}
@@ -2254,6 +3057,8 @@ snapshots:
       end-of-stream: 1.4.5
       once: 1.4.0
 
+  punycode@2.3.1: {}
+
   quick-format-unescaped@4.0.4: {}
 
   rc@1.2.8:
@@ -2376,7 +3181,7 @@ snapshots:
     dependencies:
       js-tokens: 9.0.1
 
-  svelte-check@4.7.2(picomatch@4.0.5)(svelte@5.56.4)(typescript@5.9.3):
+  svelte-check@4.7.2(picomatch@4.0.5)(svelte@5.56.4(@typescript-eslint/types@8.63.0))(typescript@5.9.3):
     dependencies:
       '@jridgewell/trace-mapping': 0.3.31
       '@sveltejs/load-config': 0.2.0
@@ -2384,12 +3189,24 @@ snapshots:
       fdir: 6.5.0(picomatch@4.0.5)
       picocolors: 1.1.1
       sade: 1.8.1
-      svelte: 5.56.4
+      svelte: 5.56.4(@typescript-eslint/types@8.63.0)
       typescript: 5.9.3
     transitivePeerDependencies:
       - picomatch
 
-  svelte@5.56.4:
+  svelte-eslint-parser@1.8.0(svelte@5.56.4(@typescript-eslint/types@8.63.0)):
+    dependencies:
+      eslint-scope: 8.4.0
+      eslint-visitor-keys: 4.2.1
+      espree: 10.4.0
+      postcss: 8.5.16
+      postcss-scss: 4.0.9(postcss@8.5.16)
+      postcss-selector-parser: 7.1.4
+      semver: 7.8.5
+    optionalDependencies:
+      svelte: 5.56.4(@typescript-eslint/types@8.63.0)
+
+  svelte@5.56.4(@typescript-eslint/types@8.63.0):
     dependencies:
       '@jridgewell/remapping': 2.3.5
       '@jridgewell/sourcemap-codec': 1.5.5
@@ -2402,7 +3219,7 @@ snapshots:
       clsx: 2.1.1
       devalue: 5.8.1
       esm-env: 1.2.2
-      esrap: 2.2.13
+      esrap: 2.2.13(@typescript-eslint/types@8.63.0)
       is-reference: 3.0.3
       locate-character: 3.0.0
       magic-string: 0.30.21
@@ -2448,6 +3265,10 @@ snapshots:
 
   toidentifier@1.0.1: {}
 
+  ts-api-utils@2.5.0(typescript@5.9.3):
+    dependencies:
+      typescript: 5.9.3
+
   tsx@4.23.0:
     dependencies:
       esbuild: 0.28.1
@@ -2458,10 +3279,29 @@ snapshots:
     dependencies:
       safe-buffer: 5.2.1
 
+  type-check@0.4.0:
+    dependencies:
+      prelude-ls: 1.2.1
+
+  typescript-eslint@8.63.0(eslint@10.6.0)(typescript@5.9.3):
+    dependencies:
+      '@typescript-eslint/eslint-plugin': 8.63.0(@typescript-eslint/parser@8.63.0(eslint@10.6.0)(typescript@5.9.3))(eslint@10.6.0)(typescript@5.9.3)
+      '@typescript-eslint/parser': 8.63.0(eslint@10.6.0)(typescript@5.9.3)
+      '@typescript-eslint/typescript-estree': 8.63.0(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.63.0(eslint@10.6.0)(typescript@5.9.3)
+      eslint: 10.6.0
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - supports-color
+
   typescript@5.9.3: {}
 
   undici-types@6.21.0: {}
 
+  uri-js@4.4.1:
+    dependencies:
+      punycode: 2.3.1
+
   util-deprecate@1.0.2: {}
 
   vite-node@3.2.4(@types/node@22.20.1)(tsx@4.23.0):
@@ -2565,8 +3405,14 @@ snapshots:
       siginfo: 2.0.0
       stackback: 0.0.2
 
+  word-wrap@1.2.5: {}
+
   wrappy@1.0.2: {}
 
   ws@8.21.0: {}
 
+  yaml@1.10.3: {}
+
+  yocto-queue@0.1.0: {}
+
   zimmerframe@1.1.4: {}
diff --git a/server/scripts/spike-claude.ts b/server/scripts/spike-claude.ts
index cccf288..a55f26b 100644
--- a/server/scripts/spike-claude.ts
+++ b/server/scripts/spike-claude.ts
@@ -30,8 +30,14 @@ const cwd = mkdtempSync(path.join(tmpdir(), 'hub-spike-'));
 writeFileSync(OUT, '');
 
 const env = { ...process.env };
-for (const k of ['CLAUDECODE', 'CLAUDE_CODE_ENTRYPOINT', 'CLAUDE_CODE_SESSION_ID',
-                 'CLAUDE_CODE_REMOTE_SESSION_ID', 'CLAUDE_CODE_CHILD_SESSION']) delete env[k];
+for (const k of [
+  'CLAUDECODE',
+  'CLAUDE_CODE_ENTRYPOINT',
+  'CLAUDE_CODE_SESSION_ID',
+  'CLAUDE_CODE_REMOTE_SESSION_ID',
+  'CLAUDE_CODE_CHILD_SESSION',
+])
+  delete env[k];
 
 interface RunState {
   child: ReturnType<typeof spawn>;
@@ -40,11 +46,24 @@ interface RunState {
 }
 
 function run(resume?: string): RunState {
-  const args = ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json',
-    '--verbose', '--permission-prompt-tool', 'stdio', '--model', 'claude-haiku-4-5-20251001'];
+  const args = [
+    '-p',
+    '--input-format',
+    'stream-json',
+    '--output-format',
+    'stream-json',
+    '--verbose',
+    '--permission-prompt-tool',
+    'stdio',
+    '--model',
+    'claude-haiku-4-5-20251001',
+  ];
   if (resume) args.push('--resume', resume);
   const child = spawn(process.env.CLAUDE_BIN ?? 'claude', args, {
-    cwd, env, stdio: ['pipe', 'pipe', 'inherit'], detached: true,
+    cwd,
+    env,
+    stdio: ['pipe', 'pipe', 'inherit'],
+    detached: true,
   });
   const state: RunState = { child, onResult: [] };
   let buf = '';
@@ -57,7 +76,11 @@ function run(resume?: string): RunState {
       if (!line.trim()) continue;
       appendFileSync(OUT, line + '\n');
       let msg: Record<string, unknown>;
-      try { msg = JSON.parse(line) as Record<string, unknown>; } catch { continue; }
+      try {
+        msg = JSON.parse(line) as Record<string, unknown>;
+      } catch {
+        continue;
+      }
       if (msg.type === 'system' && msg.subtype === 'init') {
         state.sessionId = msg.session_id as string;
         console.log('init: session_id =', state.sessionId);
@@ -65,9 +88,15 @@ function run(resume?: string): RunState {
       if (msg.type === 'control_request') {
         const req = msg.request as { subtype: string; tool_name?: string; input?: unknown };
         console.log('control_request:', req.subtype, req.tool_name ?? '');
-        send(child, { type: 'control_response', response: { subtype: 'success',
-          request_id: msg.request_id, response: req.subtype === 'can_use_tool'
-            ? { behavior: 'allow', updatedInput: req.input } : {} } });
+        send(child, {
+          type: 'control_response',
+          response: {
+            subtype: 'success',
+            request_id: msg.request_id,
+            response:
+              req.subtype === 'can_use_tool' ? { behavior: 'allow', updatedInput: req.input } : {},
+          },
+        });
       }
       if (msg.type === 'result') {
         console.log('result:', msg.subtype, 'cost:', msg.total_cost_usd);
@@ -100,7 +129,11 @@ await waitResult(a);
 console.log('--- turn 3: interrupt mid-generation');
 user(a.child, 'Count from 1 to 300, one number per line.');
 await new Promise((r) => setTimeout(r, 4000));
-send(a.child, { type: 'control_request', request_id: 'spike-int', request: { subtype: 'interrupt' } });
+send(a.child, {
+  type: 'control_request',
+  request_id: 'spike-int',
+  request: { subtype: 'interrupt' },
+});
 await waitResult(a);
 const sessionId = a.sessionId!;
 a.child.stdin!.end();
@@ -110,7 +143,13 @@ console.log('--- resume with --resume', sessionId);
 const b = run(sessionId);
 user(b.child, 'What is in hello.txt? Reply with just its content.');
 await waitResult(b);
-console.log('resumed session_id:', b.sessionId, '(same as original:', b.sessionId === sessionId, ')');
+console.log(
+  'resumed session_id:',
+  b.sessionId,
+  '(same as original:',
+  b.sessionId === sessionId,
+  ')',
+);
 b.child.stdin!.end();
 await new Promise((r) => b.child.on('exit', r));
 console.log('spike complete; raw log at', OUT);
diff --git a/server/src/api/routes.ts b/server/src/api/routes.ts
index f201840..2325778 100644
--- a/server/src/api/routes.ts
+++ b/server/src/api/routes.ts
@@ -1,9 +1,5 @@
 import type { FastifyInstance } from 'fastify';
-import type {
-  CreateSessionRequest,
-  FsValidateRequest,
-  UpdateSessionRequest,
-} from '@hub/shared';
+import type { CreateSessionRequest, FsValidateRequest, UpdateSessionRequest } from '@hub/shared';
 import { bearerToken, tokenMatches } from '../auth.js';
 import type { HubConfig } from '../config.js';
 import type { EventsRepo } from '../db/repos.js';
@@ -33,8 +29,7 @@ export function registerRoutes(app: FastifyInstance, deps: RouteDeps): void {
 
   app.setErrorHandler((err, _req, reply) => {
     if (err instanceof HubError) {
-      const status =
-        err.code === 'not_found' ? 404 : err.code === 'session_busy' ? 409 : 400;
+      const status = err.code === 'not_found' ? 404 : err.code === 'session_busy' ? 409 : 400;
       return reply.code(status).send({ error: err.code, message: err.message });
     }
     const fastifyErr = err as { statusCode?: number; code?: string; message?: string };
@@ -62,7 +57,9 @@ export function registerRoutes(app: FastifyInstance, deps: RouteDeps): void {
   app.post('/api/sessions', async (req, reply) => {
     const body = req.body as CreateSessionRequest;
     if (!body?.engineId || !body?.cwd) {
-      return reply.code(400).send({ error: 'bad_request', message: 'engineId and cwd are required' });
+      return reply
+        .code(400)
+        .send({ error: 'bad_request', message: 'engineId and cwd are required' });
     }
     return manager.create(body);
   });
@@ -104,7 +101,8 @@ export function registerRoutes(app: FastifyInstance, deps: RouteDeps): void {
 
   app.post('/api/fs/validate', async (req, reply) => {
     const body = req.body as FsValidateRequest;
-    if (!body?.path) return reply.code(400).send({ error: 'bad_request', message: 'path required' });
+    if (!body?.path)
+      return reply.code(400).send({ error: 'bad_request', message: 'path required' });
     return validateCwd(config.workspaceRoots, body.path);
   });
 
diff --git a/server/src/api/ws.ts b/server/src/api/ws.ts
index 6c27968..f58464e 100644
--- a/server/src/api/ws.ts
+++ b/server/src/api/ws.ts
@@ -41,7 +41,8 @@ export function attachWebSocket(server: HttpServer, deps: WsDeps): WebSocketServ
       }
     };
     const onDelta = (sessionId: string, messageKey: string, delta: string): void => {
-      if (subscriptions.has(sessionId)) send({ type: 'stream_delta', sessionId, messageKey, delta });
+      if (subscriptions.has(sessionId))
+        send({ type: 'stream_delta', sessionId, messageKey, delta });
     };
     const onStatus = (sessionId: string, status: SessionStatus): void => {
       if (authed) send({ type: 'status', sessionId, status });
@@ -127,7 +128,13 @@ export function attachWebSocket(server: HttpServer, deps: WsDeps): WebSocketServ
             history = deps.events.listRecent(msg.sessionId, limit);
           }
           for (const e of history) {
-            send({ type: 'event', sessionId: e.sessionId, eventId: e.id, ts: e.ts, event: e.event });
+            send({
+              type: 'event',
+              sessionId: e.sessionId,
+              eventId: e.id,
+              ts: e.ts,
+              event: e.event,
+            });
           }
           // Only the bounded initial load reports whether older history exists;
           // forward catch-up must not overwrite the client's existing cursor.
diff --git a/server/src/bus.ts b/server/src/bus.ts
index df7f6c8..842f3b2 100644
--- a/server/src/bus.ts
+++ b/server/src/bus.ts
@@ -13,7 +13,10 @@ export interface HubBusEvents {
 }
 
 export class HubBus extends EventEmitter {
-  override emit<K extends keyof HubBusEvents>(event: K, ...args: Parameters<HubBusEvents[K]>): boolean {
+  override emit<K extends keyof HubBusEvents>(
+    event: K,
+    ...args: Parameters<HubBusEvents[K]>
+  ): boolean {
     return super.emit(event, ...args);
   }
   override on<K extends keyof HubBusEvents>(event: K, listener: HubBusEvents[K]): this {
diff --git a/server/src/config.ts b/server/src/config.ts
index 32d4ad8..bd5fb0d 100644
--- a/server/src/config.ts
+++ b/server/src/config.ts
@@ -42,10 +42,15 @@ export function loadConfig(env: NodeJS.ProcessEnv = process.env): HubConfig {
     dataDir,
     workspaceRoots,
     worktreeRoot: path.resolve(env.WORKTREE_ROOT ?? path.join(dataDir, 'worktrees')),
-    engines: (env.ENGINES ?? 'claude-code,echo').split(',').map((s) => s.trim()).filter(Boolean),
+    engines: (env.ENGINES ?? 'claude-code,echo')
+      .split(',')
+      .map((s) => s.trim())
+      .filter(Boolean),
     claudeBin: env.CLAUDE_BIN || undefined,
     logLevel: env.LOG_LEVEL ?? 'info',
-    engineIdleTimeoutMs: env.ENGINE_IDLE_TIMEOUT_MS ? Number(env.ENGINE_IDLE_TIMEOUT_MS) : 30 * 60_000,
+    engineIdleTimeoutMs: env.ENGINE_IDLE_TIMEOUT_MS
+      ? Number(env.ENGINE_IDLE_TIMEOUT_MS)
+      : 30 * 60_000,
     approvalTimeoutMs: env.APPROVAL_TIMEOUT_MS ? Number(env.APPROVAL_TIMEOUT_MS) : 0,
     webDistDir: env.WEB_DIST_DIR || undefined,
   };
diff --git a/server/src/db/database.ts b/server/src/db/database.ts
index 71570fe..c3bd74f 100644
--- a/server/src/db/database.ts
+++ b/server/src/db/database.ts
@@ -97,7 +97,9 @@ export function openDatabase(dataDir: string, filename = 'hub.db'): Database.Dat
 }
 
 function migrate(db: Database.Database): void {
-  db.exec('CREATE TABLE IF NOT EXISTS migrations (id INTEGER PRIMARY KEY, applied_at INTEGER NOT NULL)');
+  db.exec(
+    'CREATE TABLE IF NOT EXISTS migrations (id INTEGER PRIMARY KEY, applied_at INTEGER NOT NULL)',
+  );
   const applied = new Set(
     (db.prepare('SELECT id FROM migrations').all() as { id: number }[]).map((r) => r.id),
   );
diff --git a/server/src/db/repos.ts b/server/src/db/repos.ts
index ba9fff9..8f9380e 100644
--- a/server/src/db/repos.ts
+++ b/server/src/db/repos.ts
@@ -131,8 +131,7 @@ export class SessionsRepo {
   /** Whether a forked session still needs --fork-session on its next engine start. */
   forkPending(id: string): boolean {
     const row = this.db.prepare('SELECT fork_pending FROM sessions WHERE id = ?').get(id) as
-      | { fork_pending: number }
-      | undefined;
+      { fork_pending: number } | undefined;
     return !!row && row.fork_pending !== 0;
   }
 
@@ -143,8 +142,7 @@ export class SessionsRepo {
 
   get(id: string): SessionDto | undefined {
     const row = this.db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as
-      | SessionRow
-      | undefined;
+      SessionRow | undefined;
     return row ? toDto(row) : undefined;
   }
 
@@ -187,7 +185,9 @@ export class SessionsRepo {
   }
 
   setStatus(id: string, status: SessionStatus): void {
-    this.db.prepare('UPDATE sessions SET status = ?, updated_at = ? WHERE id = ?').run(status, Date.now(), id);
+    this.db
+      .prepare('UPDATE sessions SET status = ?, updated_at = ? WHERE id = ?')
+      .run(status, Date.now(), id);
   }
 
   setPid(id: string, pid: number | null): void {
@@ -209,7 +209,9 @@ export class SessionsRepo {
       this.db.prepare('UPDATE sessions SET model = ? WHERE id = ?').run(meta.model, id);
     }
     if (meta.lastCostUsd !== undefined) {
-      this.db.prepare('UPDATE sessions SET last_cost_usd = ? WHERE id = ?').run(meta.lastCostUsd, id);
+      this.db
+        .prepare('UPDATE sessions SET last_cost_usd = ? WHERE id = ?')
+        .run(meta.lastCostUsd, id);
     }
   }
 
@@ -226,8 +228,7 @@ export class SessionsRepo {
 
   pidOf(id: string): number | null {
     const row = this.db.prepare('SELECT pid FROM sessions WHERE id = ?').get(id) as
-      | { pid: number | null }
-      | undefined;
+      { pid: number | null } | undefined;
     return row?.pid ?? null;
   }
 }
@@ -241,7 +242,12 @@ interface EventRow {
 }
 
 function rowToEvent(r: EventRow): SessionEvent {
-  return { id: r.id, sessionId: r.session_id, ts: r.ts, event: JSON.parse(r.payload) as NormalizedEvent };
+  return {
+    id: r.id,
+    sessionId: r.session_id,
+    ts: r.ts,
+    event: JSON.parse(r.payload) as NormalizedEvent,
+  };
 }
 
 export class EventsRepo {
@@ -310,7 +316,9 @@ export class EventsRepo {
          )`,
       )
       .all(sessionId, sessionId) as { payload: string }[];
-    return rows.map((r) => ({ requestId: (JSON.parse(r.payload) as { requestId: string }).requestId }));
+    return rows.map((r) => ({
+      requestId: (JSON.parse(r.payload) as { requestId: string }).requestId,
+    }));
   }
 
   lastEvent(sessionId: string): SessionEvent | undefined {
@@ -318,6 +326,11 @@ export class EventsRepo {
       .prepare('SELECT * FROM events WHERE session_id = ? ORDER BY id DESC LIMIT 1')
       .get(sessionId) as EventRow | undefined;
     if (!r) return undefined;
-    return { id: r.id, sessionId: r.session_id, ts: r.ts, event: JSON.parse(r.payload) as NormalizedEvent };
+    return {
+      id: r.id,
+      sessionId: r.session_id,
+      ts: r.ts,
+      event: JSON.parse(r.payload) as NormalizedEvent,
+    };
   }
 }
diff --git a/server/src/engines/claude/ClaudeCodeAdapter.ts b/server/src/engines/claude/ClaudeCodeAdapter.ts
index e8f1495..f547cf2 100644
--- a/server/src/engines/claude/ClaudeCodeAdapter.ts
+++ b/server/src/engines/claude/ClaudeCodeAdapter.ts
@@ -75,10 +75,13 @@ class ClaudeRun implements EngineRun {
   constructor(bin: string, extraArgs: string[], opts: StartOptions) {
     const args = [
       '-p',
-      '--input-format', 'stream-json',
-      '--output-format', 'stream-json',
+      '--input-format',
+      'stream-json',
+      '--output-format',
+      'stream-json',
       '--verbose',
-      '--permission-prompt-tool', 'stdio',
+      '--permission-prompt-tool',
+      'stdio',
       '--include-partial-messages',
     ];
     // Per-session config passthrough; each unset value inherits the ~/.claude default.
@@ -223,7 +226,11 @@ class ClaudeRun implements EngineRun {
     });
   }
 
-  respondToApproval(requestId: string, behavior: 'allow' | 'deny', opts?: { message?: string }): void {
+  respondToApproval(
+    requestId: string,
+    behavior: 'allow' | 'deny',
+    opts?: { message?: string },
+  ): void {
     const pending = this.pendingApprovals.get(requestId);
     if (!pending) return;
     this.pendingApprovals.delete(requestId);
diff --git a/server/src/engines/echo/EchoAdapter.ts b/server/src/engines/echo/EchoAdapter.ts
index c5ccc35..87c9059 100644
--- a/server/src/engines/echo/EchoAdapter.ts
+++ b/server/src/engines/echo/EchoAdapter.ts
@@ -94,7 +94,11 @@ class EchoRun implements EngineRun {
 
   private approvalCallId = new Map<string, string>();
 
-  respondToApproval(requestId: string, behavior: 'allow' | 'deny', opts?: { message?: string }): void {
+  respondToApproval(
+    requestId: string,
+    behavior: 'allow' | 'deny',
+    opts?: { message?: string },
+  ): void {
     if (this.pendingApproval?.requestId !== requestId) return;
     const { text } = this.pendingApproval;
     this.pendingApproval = null;
@@ -124,7 +128,11 @@ class EchoRun implements EngineRun {
           text: 'The echo probe was denied, so I have nothing to echo.',
           messageKey: `echo-msg-${randomUUID()}`,
         });
-        this.emit({ type: 'done', reason: 'complete', usage: { inputTokens: 1, outputTokens: 1, costUsd: 0 } });
+        this.emit({
+          type: 'done',
+          reason: 'complete',
+          usage: { inputTokens: 1, outputTokens: 1, costUsd: 0 },
+        });
       });
       return;
     }
diff --git a/server/src/fs/git.ts b/server/src/fs/git.ts
index 6e8bb48..dfd4bc9 100644
--- a/server/src/fs/git.ts
+++ b/server/src/fs/git.ts
@@ -23,9 +23,14 @@ export function gitInfo(cwd: string): GitInfoResponse {
   const currentBranch = head.ok && head.out && head.out !== 'HEAD' ? head.out : null;
 
   const list = run(cwd, ['for-each-ref', '--format=%(refname:short)', 'refs/heads']);
-  const branches = list.ok ? list.out.split('\n').map((s) => s.trim()).filter(Boolean) : [];
+  const branches = list.ok
+    ? list.out
+        .split('\n')
+        .map((s) => s.trim())
+        .filter(Boolean)
+    : [];
 
-  let defaultBranch: string | null = null;
+  let defaultBranch: string | null;
   const originHead = run(cwd, ['symbolic-ref', '--short', 'refs/remotes/origin/HEAD']);
   if (originHead.ok && originHead.out) defaultBranch = originHead.out.replace(/^origin\//, '');
   else if (branches.includes('main')) defaultBranch = 'main';
@@ -81,7 +86,8 @@ export function removeWorktree(worktreePath: string): void {
     encoding: 'utf8',
     timeout: GIT_WORKTREE_TIMEOUT_MS,
   });
-  if (rm.status !== 0) spawnSync('git', ['-C', mainRepo, 'worktree', 'prune'], { timeout: GIT_TIMEOUT_MS });
+  if (rm.status !== 0)
+    spawnSync('git', ['-C', mainRepo, 'worktree', 'prune'], { timeout: GIT_TIMEOUT_MS });
 
   // Only ever delete hub-managed branches, never a user branch.
   if (branch.startsWith('hub/')) {
diff --git a/server/src/sessions/SessionRuntime.ts b/server/src/sessions/SessionRuntime.ts
index 5aedf14..35964f1 100644
--- a/server/src/sessions/SessionRuntime.ts
+++ b/server/src/sessions/SessionRuntime.ts
@@ -97,7 +97,11 @@ export class SessionRuntime {
         if (this.busy) {
           this.busy = false;
           this.clearApprovalState();
-          this.persist({ type: 'done', reason: 'error', errorMessage: 'engine process exited unexpectedly' });
+          this.persist({
+            type: 'done',
+            reason: 'error',
+            errorMessage: 'engine process exited unexpectedly',
+          });
           this.setStatus('error');
         }
         this.setEngineState('dead');
diff --git a/server/test/adapter-contract.ts b/server/test/adapter-contract.ts
index 3f63e7e..2bbb12b 100644
--- a/server/test/adapter-contract.ts
+++ b/server/test/adapter-contract.ts
@@ -39,9 +39,10 @@ export function adapterContract(makeAdapter: () => EngineAdapter, opts: { cwd: s
     const results = events.filter((e) => e.type === 'tool_result');
     const callIds = new Set(calls.map((c) => (c as { callId: string }).callId));
     for (const r of results) {
-      expect(callIds.has((r as { callId: string }).callId), 'tool_result pairs with tool_call').toBe(
-        true,
-      );
+      expect(
+        callIds.has((r as { callId: string }).callId),
+        'tool_result pairs with tool_call',
+      ).toBe(true);
     }
 
     expect(events.some((e) => e.type === 'message')).toBe(true);
@@ -83,7 +84,8 @@ export function adapterContract(makeAdapter: () => EngineAdapter, opts: { cwd: s
     const done = new Promise<void>((resolve) => {
       run.onEvent((e) => {
         events.push(e);
-        if (e.type === 'approval_request') run.respondToApproval(e.requestId, 'deny', { message: 'no' });
+        if (e.type === 'approval_request')
+          run.respondToApproval(e.requestId, 'deny', { message: 'no' });
         if (e.type === 'done') resolve();
       });
     });
diff --git a/server/test/e2e.test.ts b/server/test/e2e.test.ts
index 5d8d42f..0c5551d 100644
--- a/server/test/e2e.test.ts
+++ b/server/test/e2e.test.ts
@@ -73,7 +73,10 @@ class Client {
 
   events(sessionId: string): SessionEvent[] {
     return this.received
-      .filter((m): m is Extract<ServerMsg, { type: 'event' }> => m.type === 'event' && m.sessionId === sessionId)
+      .filter(
+        (m): m is Extract<ServerMsg, { type: 'event' }> =>
+          m.type === 'event' && m.sessionId === sessionId,
+      )
       .map((m) => ({ id: m.eventId, sessionId: m.sessionId, ts: m.ts, event: m.event }));
   }
 
@@ -135,7 +138,8 @@ describe('end-to-end with echo engine', () => {
     c.send({ type: 'user_message', sessionId: session.id, text: 'hello world' });
 
     const approval = await c.next(
-      (m) => m.type === 'event' && m.sessionId === session.id && m.event.type === 'approval_request',
+      (m) =>
+        m.type === 'event' && m.sessionId === session.id && m.event.type === 'approval_request',
     );
     const requestId = (approval as { event: { requestId: string } }).event.requestId;
 
@@ -154,7 +158,9 @@ describe('end-to-end with echo engine', () => {
     expect(deltas.length).toBeGreaterThan(0);
     const finalMsg = c
       .events(session.id)
-      .find((e) => e.event.type === 'message' && (e.event as { role: string }).role === 'assistant');
+      .find(
+        (e) => e.event.type === 'message' && (e.event as { role: string }).role === 'assistant',
+      );
     expect(finalMsg).toBeTruthy();
     expect((finalMsg!.event as { messageKey: string }).messageKey).toBe(deltas[0]!.messageKey);
     expect(deltas.map((d) => d.delta).join('')).toBe((finalMsg!.event as { text: string }).text);
@@ -177,7 +183,8 @@ describe('end-to-end with echo engine', () => {
     c.send({ type: 'subscribe', sessionId: hanging.id });
     c.send({ type: 'user_message', sessionId: hanging.id, text: 'never approved' });
     await c.next(
-      (m) => m.type === 'event' && m.sessionId === hanging.id && m.event.type === 'approval_request',
+      (m) =>
+        m.type === 'event' && m.sessionId === hanging.id && m.event.type === 'approval_request',
     );
 
     c.close();
@@ -275,9 +282,9 @@ describe('end-to-end with echo engine', () => {
 
     // The engine applies the mode itself, so nothing is asked: no awaiting_approval
     // status and no approval events at all, yet the tool still ran.
-    expect(
-      c.received.some((m) => m.type === 'status' && m.status === 'awaiting_approval'),
-    ).toBe(false);
+    expect(c.received.some((m) => m.type === 'status' && m.status === 'awaiting_approval')).toBe(
+      false,
+    );
     const types = c.events(session.id).map((e) => e.event.type);
     expect(types).not.toContain('approval_request');
     expect(types).not.toContain('approval_resolved');
@@ -319,7 +326,10 @@ describe('end-to-end with echo engine', () => {
     // Explicit stop tears the process down but keeps the session resumable.
     c.send({ type: 'stop_engine', sessionId: session.id });
     await c.next(
-      (m) => m.type === 'session_upsert' && m.session.id === session.id && m.session.engineState === 'hibernated',
+      (m) =>
+        m.type === 'session_upsert' &&
+        m.session.id === session.id &&
+        m.session.engineState === 'hibernated',
     );
     const hibernated = await api<SessionDto>(port, 'GET', `/api/sessions/${session.id}`);
     expect(hibernated.engineState).toBe('hibernated');
@@ -366,7 +376,10 @@ describe('end-to-end with echo engine', () => {
     const d1id = (d1 as Extract<ServerMsg, { type: 'event' }>).eventId;
     await c.next(
       (m) =>
-        m.type === 'event' && m.sessionId === session.id && m.event.type === 'done' && m.eventId > d1id,
+        m.type === 'event' &&
+        m.sessionId === session.id &&
+        m.event.type === 'done' &&
+        m.eventId > d1id,
       10_000,
     );
 
diff --git a/shared/src/events.ts b/shared/src/events.ts
index 1a60111..e5d7d0b 100644
--- a/shared/src/events.ts
+++ b/shared/src/events.ts
@@ -19,12 +19,7 @@ export type PermissionMode =
   | 'dontAsk' // auto-deny unless pre-allowed by settings rules
   | 'bypassPermissions'; // skip prompts (except explicit ask rules / circuit breakers)
 
-export type SessionStatus =
-  | 'idle'
-  | 'starting'
-  | 'running'
-  | 'awaiting_approval'
-  | 'error';
+export type SessionStatus = 'idle' | 'starting' | 'running' | 'awaiting_approval' | 'error';
 
 /**
  * Engine-process liveness, independent of the interaction `status`. A session
diff --git a/web/src/App.svelte b/web/src/App.svelte
index f67555c..1596d26 100644
--- a/web/src/App.svelte
+++ b/web/src/App.svelte
@@ -50,7 +50,7 @@
       {#if $activeSessionId && $sessions.some((s) => s.id === $activeSessionId)}
         <ChatView sessionId={$activeSessionId} {showToast} />
       {:else}
-        <Launcher {showToast} />
+        <Launcher />
       {/if}
     </main>
   </div>
diff --git a/web/src/app.css b/web/src/app.css
index b038cd6..e08d330 100644
--- a/web/src/app.css
+++ b/web/src/app.css
@@ -123,9 +123,34 @@ textarea:focus {
 }
 
 /* highlight.js (dark) minimal theme */
-.hljs-keyword, .hljs-selector-tag, .hljs-literal, .hljs-section { color: #c678dd; }
-.hljs-string, .hljs-attr, .hljs-template-tag { color: #98c379; }
-.hljs-number, .hljs-symbol, .hljs-bullet { color: #d19a66; }
-.hljs-title, .hljs-name, .hljs-type { color: #61afef; }
-.hljs-comment, .hljs-quote, .hljs-meta { color: #7f848e; font-style: italic; }
-.hljs-variable, .hljs-regexp { color: #e06c75; }
+.hljs-keyword,
+.hljs-selector-tag,
+.hljs-literal,
+.hljs-section {
+  color: #c678dd;
+}
+.hljs-string,
+.hljs-attr,
+.hljs-template-tag {
+  color: #98c379;
+}
+.hljs-number,
+.hljs-symbol,
+.hljs-bullet {
+  color: #d19a66;
+}
+.hljs-title,
+.hljs-name,
+.hljs-type {
+  color: #61afef;
+}
+.hljs-comment,
+.hljs-quote,
+.hljs-meta {
+  color: #7f848e;
+  font-style: italic;
+}
+.hljs-variable,
+.hljs-regexp {
+  color: #e06c75;
+}
diff --git a/web/src/components/ApprovalCard.svelte b/web/src/components/ApprovalCard.svelte
index 632eff3..022267a 100644
--- a/web/src/components/ApprovalCard.svelte
+++ b/web/src/components/ApprovalCard.svelte
@@ -28,7 +28,11 @@
     const { behavior, resolvedBy } = approval.resolved;
     const verb = behavior === 'allow' ? 'Allowed' : 'Denied';
     const by =
-      resolvedBy === 'user' ? 'by you' : resolvedBy === 'policy' ? 'by policy' : '(expired on restart)';
+      resolvedBy === 'user'
+        ? 'by you'
+        : resolvedBy === 'policy'
+          ? 'by policy'
+          : '(expired on restart)';
     return `${verb} ${by}`;
   });
 </script>
@@ -50,14 +54,16 @@
     {#if suggestions.length}
       <div class="suggestions">
         <span class="sg-label">CLI suggests</span>
-        {#each suggestions as sg}
+        {#each suggestions as sg, i (i)}
           <span class="chip" title={sg}>{sg}</span>
         {/each}
       </div>
     {/if}
     <div class="actions">
       <button class="primary" disabled={responded} onclick={allow}>Allow</button>
-      <button class="danger" disabled={responded} onclick={() => (showDeny = !showDeny)}>Deny…</button>
+      <button class="danger" disabled={responded} onclick={() => (showDeny = !showDeny)}
+        >Deny…</button
+      >
       {#if showDeny}
         <input
           placeholder="optional reason sent to the agent"
diff --git a/web/src/components/ChatView.svelte b/web/src/components/ChatView.svelte
index 9c63b19..10bb3dd 100644
--- a/web/src/components/ChatView.svelte
+++ b/web/src/components/ChatView.svelte
@@ -128,8 +128,7 @@
         ? 'Queue a follow-up (runs after this turn, Enter to send)…'
         : 'Message the agent (Enter to send, Shift+Enter for newline)'}
       bind:value={composer}
-      onkeydown={onKeydown}
-    ></textarea>
+      onkeydown={onKeydown}></textarea>
     <div class="composer-actions">
       {#if busy}
         <button class="danger" onclick={() => sendInterrupt(sessionId)}>■ Interrupt</button>
diff --git a/web/src/components/DoneMarker.svelte b/web/src/components/DoneMarker.svelte
index 187e587..952f80d 100644
--- a/web/src/components/DoneMarker.svelte
+++ b/web/src/components/DoneMarker.svelte
@@ -15,7 +15,9 @@
   const label = $derived.by(() => {
     switch (reason) {
       case 'complete':
-        return formatCost(usage?.costUsd) ? `turn complete · ${formatCost(usage?.costUsd)}` : 'turn complete';
+        return formatCost(usage?.costUsd)
+          ? `turn complete · ${formatCost(usage?.costUsd)}`
+          : 'turn complete';
       case 'interrupted':
         return 'interrupted';
       case 'killed':
diff --git a/web/src/components/Launcher.svelte b/web/src/components/Launcher.svelte
index f916327..e7460f0 100644
--- a/web/src/components/Launcher.svelte
+++ b/web/src/components/Launcher.svelte
@@ -11,8 +11,6 @@
   import { PERMISSION_MODES } from '../lib/format.js';
   import { activeSessionId, sessions, upsertSession } from '../lib/stores.js';
 
-  let { showToast }: { showToast: (m: string) => void } = $props();
-
   let engines = $state<EngineDescriptor[]>([]);
   let engineId = $state('');
   let cwd = $state('');
@@ -36,9 +34,9 @@
   const showEnginePicker = $derived(availableEngines.length > 1);
   const selectedMode = $derived(PERMISSION_MODES.find((m) => m.value === permissionMode));
   // Real project dirs from prior sessions (exclude ephemeral worktree sessions).
-  const recentProjects = $derived([
-    ...new Set($sessions.filter((s) => !s.worktreePath).map((s) => s.cwd)),
-  ].slice(0, 6));
+  const recentProjects = $derived(
+    [...new Set($sessions.filter((s) => !s.worktreePath).map((s) => s.cwd))].slice(0, 6),
+  );
   const canLaunch = $derived(!launching && !!engineId && !!validation?.ok);
 
   onMount(async () => {
@@ -169,11 +167,15 @@
           oninput={onCwdInput}
           spellcheck="false"
         />
-        <button type="button" onclick={() => openBrowse(validation?.ok ? cwd : undefined)}>Browse…</button>
+        <button type="button" onclick={() => openBrowse(validation?.ok ? cwd : undefined)}
+          >Browse…</button
+        >
       </div>
       {#if validation}
         {#if validation.ok}
-          <span class="hint ok">✓ {validation.resolved}{validation.isGitRepo ? ' · git repo' : ''}</span>
+          <span class="hint ok"
+            >✓ {validation.resolved}{validation.isGitRepo ? ' · git repo' : ''}</span
+          >
         {:else}
           <span class="hint bad">✗ {validation.error}</span>
         {/if}
@@ -184,7 +186,11 @@
       <div class="browser">
         <div class="browser-path">
           {#if browseData.parent !== null || browseData.path}
-            <button type="button" class="icon" onclick={() => openBrowse(browseData?.parent ?? undefined)}>↑</button>
+            <button
+              type="button"
+              class="icon"
+              onclick={() => openBrowse(browseData?.parent ?? undefined)}>↑</button
+            >
           {/if}
           <span>{browseData.path || '(workspace roots)'}</span>
         </div>
@@ -194,21 +200,25 @@
               <button type="button" class="entry-name" onclick={() => openBrowse(entry.path)}>
                 📁 {entry.name}{entry.isGitRepo ? ' ⎇' : ''}
               </button>
-              <button type="button" class="entry-pick" onclick={() => pickDir(entry.path)}>select</button>
+              <button type="button" class="entry-pick" onclick={() => pickDir(entry.path)}
+                >select</button
+              >
             </div>
           {:else}
             <p class="hint">no subdirectories</p>
           {/each}
         </div>
         {#if browseData.path}
-          <button type="button" onclick={() => pickDir(browseData!.path)}>Use this directory</button>
+          <button type="button" onclick={() => pickDir(browseData!.path)}>Use this directory</button
+          >
         {/if}
       </div>
     {/if}
 
     {#if git?.isRepo}
       <div class="field git">
-        <span class="hint dim">on branch: <strong>{git.currentBranch ?? '(detached)'}</strong></span>
+        <span class="hint dim">on branch: <strong>{git.currentBranch ?? '(detached)'}</strong></span
+        >
         <label class="check">
           <input type="checkbox" bind:checked={useWorktree} />
           Isolate in a new git worktree
@@ -238,8 +248,7 @@
         rows="3"
         placeholder="Describe what to work on. Enter launches, Shift+Enter for a newline."
         bind:value={task}
-        onkeydown={onTaskKeydown}
-      ></textarea>
+        onkeydown={onTaskKeydown}></textarea>
     </label>
 
     <div class="advanced">
@@ -275,12 +284,20 @@
 
           <label class="field">
             <span class="field-label">Model (optional)</span>
-            <input placeholder="inherit ~/.claude (e.g. opus, sonnet)" bind:value={model} spellcheck="false" />
+            <input
+              placeholder="inherit ~/.claude (e.g. opus, sonnet)"
+              bind:value={model}
+              spellcheck="false"
+            />
           </label>
 
           <label class="field">
             <span class="field-label">Settings (optional)</span>
-            <input placeholder="--settings path or inline JSON" bind:value={settings} spellcheck="false" />
+            <input
+              placeholder="--settings path or inline JSON"
+              bind:value={settings}
+              spellcheck="false"
+            />
           </label>
         </div>
       {/if}
diff --git a/web/src/components/LoginGate.svelte b/web/src/components/LoginGate.svelte
index afc45ab..70977fe 100644
--- a/web/src/components/LoginGate.svelte
+++ b/web/src/components/LoginGate.svelte
@@ -30,12 +30,7 @@
   <form onsubmit={submit}>
     <h1>agentic-cli-hub</h1>
     <p>Enter the access token (see AUTH_TOKEN in the server environment or startup log).</p>
-    <input
-      type="password"
-      placeholder="access token"
-      bind:value
-      autocomplete="current-password"
-    />
+    <input type="password" placeholder="access token" bind:value autocomplete="current-password" />
     {#if error}<p class="error">{error}</p>{/if}
     <button class="primary" type="submit" disabled={busy || !value.trim()}>Sign in</button>
   </form>
diff --git a/web/src/components/StatusBar.svelte b/web/src/components/StatusBar.svelte
index 18ea692..9526464 100644
--- a/web/src/components/StatusBar.svelte
+++ b/web/src/components/StatusBar.svelte
@@ -38,8 +38,8 @@
       <button
         class="stop"
         onclick={() => sendStopEngine(session.id)}
-        title="Stop the engine process (the session stays resumable)"
-      >stop engine</button>
+        title="Stop the engine process (the session stays resumable)">stop engine</button
+      >
     {/if}
     {#if session.model}<span class="model">{session.model}</span>{/if}
     {#if formatCost(session.lastCostUsd)}
diff --git a/web/src/components/ToolCallCard.svelte b/web/src/components/ToolCallCard.svelte
index 07871b2..2401a7d 100644
--- a/web/src/components/ToolCallCard.svelte
+++ b/web/src/components/ToolCallCard.svelte
@@ -21,7 +21,11 @@
     if (tool.input == null || typeof tool.input !== 'object') return null;
     const input = tool.input as Record<string, unknown>;
     const file = typeof input.file_path === 'string' ? input.file_path : '';
-    if (tool.toolName === 'Edit' && typeof input.old_string === 'string' && typeof input.new_string === 'string') {
+    if (
+      tool.toolName === 'Edit' &&
+      typeof input.old_string === 'string' &&
+      typeof input.new_string === 'string'
+    ) {
       return { file, removed: input.old_string.split('\n'), added: input.new_string.split('\n') };
     }
     if (tool.toolName === 'Write' && typeof input.content === 'string') {
@@ -55,8 +59,10 @@
     <div class="body">
       {#if diff}
         <div class="section-label">{diff.file}</div>
-        <pre class="patch">{#each diff.removed as line}<span class="minus">- {line}
-</span>{/each}{#each diff.added as line}<span class="plus">+ {line}
+        <pre class="patch">{#each diff.removed as line, i (i)}<span class="minus"
+              >- {line}
+</span>{/each}{#each diff.added as line, i (i)}<span class="plus"
+              >+ {line}
 </span>{/each}</pre>
       {:else if tool.input !== undefined}
         <div class="section-label">input</div>
diff --git a/web/src/lib/api.ts b/web/src/lib/api.ts
index d8037c3..c026a61 100644
--- a/web/src/lib/api.ts
+++ b/web/src/lib/api.ts
@@ -59,10 +59,16 @@ export const api = {
     request<SessionDto>('PATCH', `/api/sessions/${id}`, { archived }),
   deleteSession: (id: string) => request<{ ok: boolean }>('DELETE', `/api/sessions/${id}`),
   eventsBefore: (id: string, beforeId: number, limit = 500) =>
-    request<SessionEvent[]>('GET', `/api/sessions/${id}/events?beforeId=${beforeId}&limit=${limit}`),
+    request<SessionEvent[]>(
+      'GET',
+      `/api/sessions/${id}/events?beforeId=${beforeId}&limit=${limit}`,
+    ),
   fsValidate: (path: string) => request<FsValidateResponse>('POST', '/api/fs/validate', { path }),
   fsBrowse: (path?: string) =>
-    request<FsBrowseResponse>('GET', `/api/fs/browse${path ? `?path=${encodeURIComponent(path)}` : ''}`),
+    request<FsBrowseResponse>(
+      'GET',
+      `/api/fs/browse${path ? `?path=${encodeURIComponent(path)}` : ''}`,
+    ),
   gitInfo: (cwd: string) =>
     request<GitInfoResponse>('GET', `/api/git/info?cwd=${encodeURIComponent(cwd)}`),
 };
diff --git a/web/src/lib/format.ts b/web/src/lib/format.ts
index 58ebf5c..1263f5f 100644
--- a/web/src/lib/format.ts
+++ b/web/src/lib/format.ts
@@ -49,13 +49,49 @@ export const PERMISSION_MODES: {
   hint: string;
   danger?: boolean;
 }[] = [
-  { value: null, label: 'Inherit (~/.claude)', short: 'inherit', hint: "Use the directory's own Claude settings (CLI default)" },
-  { value: 'manual', label: 'Ask for every tool', short: 'ask all', hint: 'Prompt before any tool not pre-approved' },
-  { value: 'acceptEdits', label: 'Auto-accept edits', short: 'edits ok', hint: 'Allow edits + safe fs commands, ask for the rest' },
-  { value: 'plan', label: 'Plan (read-only)', short: 'plan', hint: 'Explore and read only; edits blocked' },
-  { value: 'dontAsk', label: 'Deny unless allowlisted', short: 'deny', hint: 'Auto-deny tools not pre-approved in settings' },
-  { value: 'auto', label: 'Auto (preview)', short: 'auto', hint: 'Auto-approve with background safety checks' },
-  { value: 'bypassPermissions', label: 'Full auto (bypass)', short: 'BYPASS', hint: 'Skip prompts entirely', danger: true },
+  {
+    value: null,
+    label: 'Inherit (~/.claude)',
+    short: 'inherit',
+    hint: "Use the directory's own Claude settings (CLI default)",
+  },
+  {
+    value: 'manual',
+    label: 'Ask for every tool',
+    short: 'ask all',
+    hint: 'Prompt before any tool not pre-approved',
+  },
+  {
+    value: 'acceptEdits',
+    label: 'Auto-accept edits',
+    short: 'edits ok',
+    hint: 'Allow edits + safe fs commands, ask for the rest',
+  },
+  {
+    value: 'plan',
+    label: 'Plan (read-only)',
+    short: 'plan',
+    hint: 'Explore and read only; edits blocked',
+  },
+  {
+    value: 'dontAsk',
+    label: 'Deny unless allowlisted',
+    short: 'deny',
+    hint: 'Auto-deny tools not pre-approved in settings',
+  },
+  {
+    value: 'auto',
+    label: 'Auto (preview)',
+    short: 'auto',
+    hint: 'Auto-approve with background safety checks',
+  },
+  {
+    value: 'bypassPermissions',
+    label: 'Full auto (bypass)',
+    short: 'BYPASS',
+    hint: 'Skip prompts entirely',
+    danger: true,
+  },
 ];
 
 /** The mode that gets the red "danger" treatment in the UI. */
diff --git a/web/src/lib/timeline.ts b/web/src/lib/timeline.ts
index 0b38dfb..48ccb9a 100644
--- a/web/src/lib/timeline.ts
+++ b/web/src/lib/timeline.ts
@@ -102,7 +102,13 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         break;
       }
       case 'done':
-        items.push({ kind: 'done', id, reason: e.reason, usage: e.usage, errorMessage: e.errorMessage });
+        items.push({
+          kind: 'done',
+          id,
+          reason: e.reason,
+          usage: e.usage,
+          errorMessage: e.errorMessage,
+        });
         break;
       case 'engine_meta':
         break;
@@ -112,7 +118,9 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
 }
 
 /** The pending (unresolved) approvals, in order. */
-export function pendingApprovals(items: TimelineItem[]): Extract<TimelineItem, { kind: 'approval' }>[] {
+export function pendingApprovals(
+  items: TimelineItem[],
+): Extract<TimelineItem, { kind: 'approval' }>[] {
   return items.filter(
     (i): i is Extract<TimelineItem, { kind: 'approval' }> => i.kind === 'approval' && !i.resolved,
   );