feat: session DAG with fork detection and subagent linking (#43)

Closes #17

## Summary

- Detect conversation forks in Claude Code sessions by building a
uuid/parentUuid DAG, splitting large-gap branches into separate session
records
- Link Task tool calls to their spawned subagent sessions via
queue-operation parsing (JSON and XML formats)
- Add inline subagent conversation expansion in the frontend

## End-User Impact

- **Fork detection**: Conversation branches (e.g., from Claude Code's
"retry from here") are detected and split into separate session entries
instead of being jumbled together. Small retries (≤3 user turns) fold
into the main session; larger forks appear as standalone sessions.
- **Subagent session linking**: Task subagent conversations are linked
to the specific tool call that launched them. Task tool blocks show an
expandable inline view of the subagent's conversation.
- **Cleaner session list**: Subagent and fork sessions are hidden from
the top-level list — accessible only through their parent session
context.

## Design

**DAG from uuid/parentUuid:** Every Claude Code JSONL entry carries
`uuid` and `parentUuid` fields forming a tree. The parser builds a
parent→children adjacency map in a single pass, then walks from root
following first-child links. At fork points (nodes with multiple
children), a heuristic counts user turns remaining on the first branch:
>3 turns = real fork (split into separate `ParseResult`), ≤3 turns =
retry (follow latest child, discard older branch).

**Subagent linking from queue-operation:** Claude Code writes
`queue-operation` entries with `operation: "enqueue"` when spawning
subagents. The `content` field maps `tool_use_id` → `task_id`. Two
formats exist in the wild: JSON
(`{"task_id":"...","tool_use_id":"..."}`) and XML
(`<task-id>...</task-id><tool-use-id>...</tool-use-id>`). Parser tries
JSON first via `gjson.Get`, falls back to regex for XML tags.

**Data model — relationship_type:** Sessions gain a `relationship_type`
column (`""`, `"continuation"`, `"subagent"`, `"fork"`). Fork sessions
get ID `{parent}-{first-uuid}` with `parent_session_id` pointing to main
session. Tool calls gain `subagent_session_id` linking to the agent
session.

**API — child sessions endpoint:** `GET /api/v1/sessions/{id}/children`
returns fork/continuation/subagent sessions for a parent.

## Test plan

- [ ] Verify fork detection unit tests pass (`go test ./internal/parser/
-run TestForkDetection`)
- [ ] Verify subagent linking tests pass (`go test ./internal/parser/
-run TestSubagent`)
- [ ] Verify integration tests pass (`go test ./internal/sync/ -run
TestSync`)
- [ ] Manual: load a session with Task subagents and verify inline
expansion works
- [ ] Manual: verify subagent/fork sessions don't appear in top-level
session list

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: Wes McKinney <wesmckinn+git@gmail.com>

Author: 3 people

.roborev.toml

@@ -44,6 +44,22 @@ Key assumptions reviewers MUST account for:
    launching agentsview. Do not flag env var inheritance to agent
    CLIs as a security issue.
 
+9. SESSION FILE PARSING: Session files (JSONL, JSON) are produced by
+   agent CLIs running on the user's own machine. The parser does not
+   need to defend against adversarial or malicious input. Do not flag:
+   - Missing cycle detection in DAG/tree traversals (UUIDs are unique)
+   - Missing recursion depth limits (fork depth is bounded by human
+     interaction — each fork requires a user backtracking)
+   - Unreachable-node checks in DAG connectivity (degenerate structures
+     already fall back to linear parsing via multi-root and dangling
+     parentUuid checks)
+
+10. WRITE ATOMICITY: Session data is written per-session in individual
+    transactions. Cross-session atomicity (e.g. writing all fork
+    sessions from one file in a single transaction) is not required.
+    A full resync recovers any partial state. Do not flag non-atomic
+    multi-session writes as a data corruption risk.
+
 Do NOT flag issues that only apply to public-facing, multi-tenant,
 or network-exposed services. Focus on bugs, logic errors, data
 corruption risks, and code quality issues.

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

@@ -17,6 +17,7 @@ export interface Session {
   message_count: number;
   user_message_count: number;
   parent_session_id?: string;
+  relationship_type?: string;
   file_path?: string;
   file_size?: number;
   file_mtime?: number;
@@ -44,6 +45,7 @@ export interface ToolCall {
   input_json?: string;
   skill_name?: string;
   result_content_length?: number;
+  subagent_session_id?: string;
 }
 
 /** Matches Go Message struct in internal/db/messages.go */

frontend/src/lib/components/content/SubagentInline.svelte

@@ -0,0 +1,126 @@
+<!-- ABOUTME: Expandable inline view of a subagent's conversation.
+     ABOUTME: Lazily loads and renders subagent messages within a parent ToolBlock. -->
+<script lang="ts">
+  import type { Message } from "../../api/types.js";
+  import { getMessages } from "../../api/client.js";
+  import MessageContent from "./MessageContent.svelte";
+
+  interface Props {
+    sessionId: string;
+  }
+
+  let { sessionId }: Props = $props();
+  let expanded = $state(false);
+  let messages: Message[] | null = $state(null);
+  let loading = $state(false);
+  let error: string | null = $state(null);
+
+  async function toggleExpand() {
+    expanded = !expanded;
+    if (expanded && !messages) {
+      loading = true;
+      error = null;
+      try {
+        const resp = await getMessages(sessionId, { limit: 1000 });
+        messages = resp.messages;
+      } catch (e) {
+        error = e instanceof Error ? e.message : "Failed to load";
+      } finally {
+        loading = false;
+      }
+    }
+  }
+</script>
+
+<div class="subagent-inline">
+  <button class="subagent-toggle" onclick={toggleExpand}>
+    <span class="toggle-chevron" class:open={expanded}>&#9656;</span>
+    <span class="toggle-label">Subagent session</span>
+    <span class="toggle-session-id">{sessionId}</span>
+  </button>
+
+  {#if expanded}
+    <div class="subagent-messages">
+      {#if loading}
+        <div class="subagent-status">Loading...</div>
+      {:else if error}
+        <div class="subagent-status subagent-error">{error}</div>
+      {:else if messages && messages.length > 0}
+        {#each messages as message}
+          <MessageContent {message} />
+        {/each}
+      {:else if messages}
+        <div class="subagent-status">No messages</div>
+      {/if}
+    </div>
+  {/if}
+</div>
+
+<style>
+  .subagent-inline {
+    border-top: 1px solid var(--border-muted);
+    margin-top: 2px;
+  }
+
+  .subagent-toggle {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    padding: 6px 10px;
+    width: 100%;
+    text-align: left;
+    font-size: 11px;
+    color: var(--accent-green);
+    border-radius: 0 0 var(--radius-sm) 0;
+    transition: background 0.1s;
+  }
+
+  .subagent-toggle:hover {
+    background: var(--bg-surface-hover);
+  }
+
+  .toggle-chevron {
+    display: inline-block;
+    font-size: 10px;
+    transition: transform 0.15s;
+    flex-shrink: 0;
+  }
+
+  .toggle-chevron.open {
+    transform: rotate(90deg);
+  }
+
+  .toggle-label {
+    font-weight: 600;
+    white-space: nowrap;
+  }
+
+  .toggle-session-id {
+    font-family: var(--font-mono);
+    font-size: 10px;
+    color: var(--text-muted);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    min-width: 0;
+  }
+
+  .subagent-messages {
+    border-left: 3px solid var(--accent-green);
+    margin: 0 0 4px 10px;
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+    padding: 4px 0;
+  }
+
+  .subagent-status {
+    padding: 8px 14px;
+    font-size: 12px;
+    color: var(--text-muted);
+  }
+
+  .subagent-error {
+    color: var(--accent-red);
+  }
+</style>

frontend/src/lib/components/content/ToolBlock.svelte

@@ -1,5 +1,8 @@
+<!-- ABOUTME: Renders a collapsible tool call block with metadata tags and content. -->
+<!-- ABOUTME: Supports Task tool calls with inline subagent conversation expansion. -->
 <script lang="ts">
   import type { ToolCall } from "../../api/types.js";
+  import SubagentInline from "./SubagentInline.svelte";
 
   interface Props {
     content: string;
@@ -85,6 +88,12 @@
       ? inputParams?.prompt ?? null
       : null,
   );
+
+  let subagentSessionId = $derived(
+    toolCall?.tool_name === "Task"
+      ? toolCall?.subagent_session_id ?? null
+      : null,
+  );
 </script>
 
 <div class="tool-block">
@@ -119,6 +128,9 @@
       <pre class="tool-content">{content}</pre>
     {/if}
   {/if}
+  {#if subagentSessionId}
+    <SubagentInline sessionId={subagentSessionId} />
+  {/if}
 </div>
 
 <style>

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

@@ -130,7 +130,7 @@
 
 <div class="session-list-header">
   <span class="session-count">
-    {formatNumber(sessions.total)} sessions
+    {formatNumber(totalCount)} sessions
   </span>
   <div class="header-actions">
     {#if sessions.loading}

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

@@ -390,6 +390,7 @@ function findRoot(
     visited.add(cur);
     const s = byId.get(cur);
     if (!s?.parent_session_id) break;
+    if (s.relationship_type === "fork") break;
     const parent = s.parent_session_id;
     if (!byId.has(parent)) break; // missing link
     cur = parent;
@@ -415,6 +416,9 @@ export function buildSessionGroups(
   const insertionOrder: string[] = [];
 
   for (const s of sessions) {
+    // Subagent sessions are only visible through their parent.
+    if (s.relationship_type === "subagent") continue;
+
     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

internal/db/db.go

@@ -175,7 +175,35 @@ func needsRebuild(path string) (bool, error) {
 			"probing schema: %w", err,
 		)
 	}
-	return umcCount == 0, nil
+	if umcCount == 0 {
+		return true, nil
+	}
+
+	var relTypeCount int
+	err = conn.QueryRow(
+		`SELECT count(*) FROM pragma_table_info('sessions')
+		 WHERE name = 'relationship_type'`,
+	).Scan(&relTypeCount)
+	if err != nil {
+		return false, fmt.Errorf(
+			"probing schema: %w", err,
+		)
+	}
+	if relTypeCount == 0 {
+		return true, nil
+	}
+
+	var subagentColCount int
+	err = conn.QueryRow(
+		`SELECT count(*) FROM pragma_table_info('tool_calls')
+		 WHERE name = 'subagent_session_id'`,
+	).Scan(&subagentColCount)
+	if err != nil {
+		return false, fmt.Errorf(
+			"probing schema: %w", err,
+		)
+	}
+	return subagentColCount == 0, nil
 }
 
 func dropDatabase(path string) error {