Session continuity via sessionId chaining (#11)

## Summary

- Group continuation sessions with their originals via
`parent_session_id` chaining, extracted from Claude JSONL `sessionId`
fields
- Frontend walks `parent_session_id` chains to find root sessions and
groups all sessions sharing the same root
- Prune command excludes sessions that have children to avoid breaking
continuity chains
- Old databases (missing `parent_session_id` column) are dropped and
rebuilt from scratch on startup

## How it works

Claude JSONL files have a `sessionId` field on user/assistant records.
For original sessions, `sessionId` matches the file's UUID. For
continuations, it carries the parent file's UUID, forming a linked list
(A -> B -> C). The parser extracts this and stores it as
`parent_session_id`. The frontend walks the chain to find the root and
groups all sessions sharing the same root.

## Test plan

- [x] `go vet ./... && go test -tags fts5 ./...` -- all pass
- [x] `cd frontend && npx vitest run` -- all 318 tests pass
- [ ] Manual: delete DB, restart agentsview, verify continuation
sessions group under original with correct first message

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: wesm

frontend/src/lib/api/types/core.ts

@@ -15,6 +15,7 @@ export interface Session {
   started_at: string | null;
   ended_at: string | null;
   message_count: number;
+  parent_session_id?: string;
   file_path?: string;
   file_size?: number;
   file_mtime?: number;

frontend/src/lib/components/sidebar/SessionItem.svelte

@@ -5,11 +5,23 @@
 
   interface Props {
     session: Session;
+    continuationCount?: number;
+    groupSessionIds?: string[];
   }
 
-  let { session }: Props = $props();
-
-  let isActive = $derived(sessions.activeSessionId === session.id);
+  let {
+    session,
+    continuationCount = 1,
+    groupSessionIds,
+  }: Props = $props();
+
+  let isActive = $derived(
+    groupSessionIds
+      ? groupSessionIds.includes(
+          sessions.activeSessionId ?? "",
+        )
+      : sessions.activeSessionId === session.id,
+  );
 
   let agentColor = $derived(
     session.agent === "codex"
@@ -41,6 +53,9 @@
       <span class="session-project">{session.project}</span>
       <span class="session-time">{timeStr}</span>
       <span class="session-count">{session.message_count}</span>
+      {#if continuationCount > 1}
+        <span class="continuation-badge">x{continuationCount}</span>
+      {/if}
     </div>
   </div>
 </button>
@@ -117,4 +132,12 @@
   .session-count::before {
     content: "\2022 ";
   }
+
+  .continuation-badge {
+    font-size: 9px;
+    font-weight: 600;
+    color: var(--accent-blue);
+    white-space: nowrap;
+    flex-shrink: 0;
+  }
 </style>

frontend/src/lib/components/sidebar/SessionList.svelte

@@ -12,7 +12,8 @@
   let viewportHeight = $state(0);
   let scrollRaf: number | null = $state(null);
 
-  let totalCount = $derived(sessions.sessions.length);
+  let groups = $derived(sessions.groupedSessions);
+  let totalCount = $derived(groups.length);
 
   let startIndex = $derived(
     Math.max(
@@ -110,12 +111,23 @@
     style="height: {totalSize}px; width: 100%; position: relative;"
   >
     {#each virtualRows as row (row.key)}
-      {@const session = sessions.sessions[row.index]}
+      {@const group = groups[row.index]}
       <div
         style="position: absolute; top: 0; left: 0; width: 100%; height: {row.size}px; transform: translateY({row.start}px);"
       >
-        {#if session}
-          <SessionItem {session} />
+        {#if group}
+          {@const primary = group.sessions.find(
+            (s) => s.id === group.primarySessionId,
+          ) ?? group.sessions[0]}
+          {#if primary}
+            <SessionItem
+              session={primary}
+              continuationCount={group.sessions.length}
+              groupSessionIds={group.sessions.length > 1
+                ? group.sessions.map((s) => s.id)
+                : undefined}
+            />
+          {/if}
         {/if}
       </div>
     {/each}

frontend/src/lib/stores/sessions.svelte.ts

@@ -3,6 +3,17 @@ import type { Session, ProjectInfo } from "../api/types.js";
 
 const SESSION_PAGE_SIZE = 500;
 
+export interface SessionGroup {
+  key: string;
+  project: string;
+  sessions: Session[];
+  primarySessionId: string;
+  totalMessages: number;
+  firstMessage: string | null;
+  startedAt: string | null;
+  endedAt: string | null;
+}
+
 interface Filters {
   project: string;
   agent: string;
@@ -44,6 +55,10 @@ class SessionsStore {
     );
   }
 
+  get groupedSessions(): SessionGroup[] {
+    return buildSessionGroups(this.sessions);
+  }
+
   private get apiParams() {
     const f = this.filters;
     return {
@@ -225,4 +240,131 @@ export function createSessionsStore(): SessionsStore {
   return new SessionsStore();
 }
 
+function maxString(
+  a: string | null,
+  b: string | null,
+): string | null {
+  if (a == null) return b;
+  if (b == null) return a;
+  return a > b ? a : b;
+}
+
+function minString(
+  a: string | null,
+  b: string | null,
+): string | null {
+  if (a == null) return b;
+  if (b == null) return a;
+  return a < b ? a : b;
+}
+
+function recencyKey(s: Session): string {
+  return s.ended_at ?? s.started_at ?? s.created_at;
+}
+
+/**
+ * Walk parent_session_id chains to find the root session.
+ * If a link is missing from the loaded set, the walk stops
+ * there, forming a separate group for each disconnected
+ * subchain.
+ */
+function findRoot(
+  id: string,
+  byId: Map<string, Session>,
+  rootCache: Map<string, string>,
+): string {
+  const cached = rootCache.get(id);
+  if (cached !== undefined) return cached;
+
+  // Walk up, capping at set size to guard cycles.
+  const visited = new Set<string>();
+  let cur = id;
+  while (true) {
+    if (visited.has(cur)) break; // cycle guard
+    visited.add(cur);
+    const s = byId.get(cur);
+    if (!s?.parent_session_id) break;
+    const parent = s.parent_session_id;
+    if (!byId.has(parent)) break; // missing link
+    cur = parent;
+  }
+
+  // cur is the root — cache for every node we visited.
+  for (const v of visited) {
+    rootCache.set(v, cur);
+  }
+  return cur;
+}
+
+export function buildSessionGroups(
+  sessions: Session[],
+): SessionGroup[] {
+  const byId = new Map<string, Session>();
+  for (const s of sessions) {
+    byId.set(s.id, s);
+  }
+
+  const rootCache = new Map<string, string>();
+  const groupMap = new Map<string, SessionGroup>();
+  const insertionOrder: string[] = [];
+
+  for (const s of sessions) {
+    const root = findRoot(s.id, byId, rootCache);
+    // Sessions without a parent_session_id that aren't
+    // pointed to by anyone get root == their own id, so
+    // they form a single-session group naturally.
+    const key = root;
+
+    let group = groupMap.get(key);
+    if (!group) {
+      group = {
+        key,
+        project: s.project,
+        sessions: [],
+        primarySessionId: s.id,
+        totalMessages: 0,
+        firstMessage: null,
+        startedAt: null,
+        endedAt: null,
+      };
+      groupMap.set(key, group);
+      insertionOrder.push(key);
+    }
+
+    group.sessions.push(s);
+    group.totalMessages += s.message_count;
+    group.startedAt = minString(
+      group.startedAt,
+      s.started_at,
+    );
+    group.endedAt = maxString(group.endedAt, s.ended_at);
+  }
+
+  for (const group of groupMap.values()) {
+    if (group.sessions.length > 1) {
+      group.sessions.sort((a, b) => {
+        const ta = a.started_at ?? "";
+        const tb = b.started_at ?? "";
+        return ta < tb ? -1 : ta > tb ? 1 : 0;
+      });
+    }
+    group.firstMessage =
+      group.sessions[0]?.first_message ?? null;
+
+    let bestIdx = 0;
+    let bestKey = recencyKey(group.sessions[0]!);
+    for (let i = 1; i < group.sessions.length; i++) {
+      const key = recencyKey(group.sessions[i]!);
+      if (key > bestKey) {
+        bestKey = key;
+        bestIdx = i;
+      }
+    }
+    group.primarySessionId =
+      group.sessions[bestIdx]!.id;
+  }
+
+  return insertionOrder.map((k) => groupMap.get(k)!);
+}
+
 export const sessions = createSessionsStore();