@doccy/fell 0.1.3 → 0.2.0

package/cli.ts

@@ -26,12 +26,16 @@ import {
   formatBytes,
   openDirectory,
   checkGhStatus,
+  fetchWorktreeSessionInfo,
+  findParentSession,
   type Worktree,
   type PrStatus,
   type FileStatusResult,
   type FileEntry,
   type DirSize,
   type GhDiagnostic,
+  type SessionResult,
+  type ParentSessionResult,
 } from "./lib/git"
 import {
   c,
@@ -44,6 +48,9 @@ import {
   shortenPath,
   formatPrStatus,
   formatFileStatus,
+  formatSessionInfo,
+  formatParentSessionInline,
+  formatParentSessionExpanded,
   fellLogo,
   renderHelpLines,
   printCliHelp,
@@ -54,18 +61,23 @@ import {
 // State
 // ---------------------------------------------------------------------------
 
+/** In-flight deletion status for an item. Null when not being deleted. */
+type ItemDeleteStatus =
+  | { phase: "removing" }
+  | { phase: "branch" }
+  | { phase: "done"; message: string }
+  | { phase: "error"; message: string }
+  | { phase: "needs-force" }
+
 interface WorktreeItem {
   worktree: Worktree
   prStatus: PrStatus
   fileStatus: FileStatusResult
   dirSize: DirSize
-}
-
-/** Per-item progress entry for the deleting status line. */
-interface DeleteProgress {
-  label: string
-  status: "pending" | "removing" | "branch" | "done" | "error" | "needs-force"
-  message?: string
+  sessionInfo: SessionResult
+  parentSession: ParentSessionResult
+  /** Set during deletion. Null when the item is not being deleted. */
+  deleteStatus: ItemDeleteStatus | null
 }
 
 type Mode =
@@ -73,7 +85,6 @@ type Mode =
   | { type: "confirm-delete"; indices: number[] }
   | { type: "confirm-force"; indices: number[]; withBranch: boolean }
   | { type: "confirm-prune"; candidates: string[] }
-  | { type: "deleting"; progress: DeleteProgress[]; withBranch: boolean }
   | { type: "result"; lines: string[] }
   | { type: "help" }
 
@@ -138,9 +149,43 @@ function renderRow(
   index: number,
   state: State,
 ): string[] {
+  const wt = item.worktree
+
+  // Items being deleted render as a dimmed single line with progress icon
+  if (item.deleteStatus) {
+    const branchRaw = wt.branch ?? "(detached)"
+    const branchStr = c.dim(truncate(branchRaw, BRANCH_COL))
+    const frame = SPINNER_FRAMES[state.spinnerFrame % SPINNER_FRAMES.length]
+
+    let icon: string
+    let detail = ""
+    switch (item.deleteStatus.phase) {
+      case "removing":
+        icon = c.cyan(frame)
+        detail = c.dim(" removing")
+        break
+      case "branch":
+        icon = c.cyan(frame)
+        detail = c.dim(" deleting branch")
+        break
+      case "done":
+        icon = c.green("\u2713")
+        detail = `  ${c.dim(item.deleteStatus.message)}`
+        break
+      case "error":
+        icon = c.red("\u2717")
+        detail = `  ${c.dim(item.deleteStatus.message)}`
+        break
+      case "needs-force":
+        icon = c.yellow("!")
+        detail = c.dim(" has uncommitted changes")
+        break
+    }
+    return [`    ${icon} ${branchStr}${detail}`]
+  }
+
   const isFocused = index === state.cursor
   const isSelected = state.selected.has(index)
-  const wt = item.worktree
 
   const cursor = isFocused ? c.cyan("\u276F") : " "
   const check = isSelected ? c.lime("\u25CF") : c.dim("\u25CB")
@@ -178,7 +223,11 @@ function renderRow(
       break
   }
 
-  const mainLine = `  ${cursor} ${check} ${branchPadded}${sha}   ${pad(pr, 18)}${sizeStr}${tagStr}`
+  // Inline parent session indicator (orange dot on the main row)
+  const parentInline = formatParentSessionInline(item.parentSession)
+  const parentSuffix = parentInline ? `  ${parentInline}` : ""
+
+  const mainLine = `  ${cursor} ${check} ${branchPadded}${sha}   ${pad(pr, 18)}${sizeStr}${tagStr}${parentSuffix}`
   const lines = [mainLine]
 
   // Sub-line: dirty file status with warning icon, indented under the branch name
@@ -188,9 +237,23 @@ function renderRow(
     lines.push(`        ${fileStatusLine}`)
   }
 
-  // Expanded file list (progressive disclosure via "e" key)
+  // Expanded detail (progressive disclosure via "e" key)
   const MAX_EXPANDED_FILES = 12
+  const cols = process.stdout.columns ?? 100
   if (state.expandedIndex === index) {
+    // Session info (only in expanded view)
+    const sessionLine = formatSessionInfo(item.sessionInfo, cols - 30)
+    if (sessionLine) {
+      lines.push(`        ${sessionLine}`)
+    }
+
+    // Parent session detail (only in expanded view)
+    const parentLines = formatParentSessionExpanded(item.parentSession, cols - 20)
+    for (const pl of parentLines) {
+      lines.push(`        ${pl}`)
+    }
+
+    // File list
     if (state.expandedFiles === null) {
       const frame = SPINNER_FRAMES[state.spinnerFrame % SPINNER_FRAMES.length]
       lines.push(`        ${c.dim(`${frame} loading files...`)}`)
@@ -331,49 +394,6 @@ function render(state: State): void {
         )
         break
       }
-      case "deleting": {
-        const { progress } = state.mode
-        const done = progress.filter((p) => p.status === "done").length
-        const total = progress.length
-        const frame = SPINNER_FRAMES[state.spinnerFrame % SPINNER_FRAMES.length]
-
-        for (const entry of progress) {
-          let icon: string
-          let detail = ""
-          switch (entry.status) {
-            case "pending":
-              icon = c.dim("\u25CB")
-              break
-            case "removing":
-              icon = c.cyan(frame)
-              detail = c.dim(" removing worktree")
-              break
-            case "branch":
-              icon = c.cyan(frame)
-              detail = c.dim(" deleting branch")
-              break
-            case "done":
-              icon = c.green("\u2713")
-              detail = entry.message ? `  ${c.dim(entry.message)}` : ""
-              break
-            case "error":
-              icon = c.red("\u2717")
-              detail = entry.message ? `  ${c.dim(entry.message)}` : ""
-              break
-            case "needs-force":
-              icon = c.yellow("!")
-              detail = c.dim(" has uncommitted changes")
-              break
-          }
-          lines.push(`    ${icon} ${entry.label}${detail}`)
-        }
-
-        lines.push("")
-        lines.push(
-          `  ${c.cyan(frame)} Deleting ${done}/${total}...`,
-        )
-        break
-      }
       case "result": {
         for (const line of state.mode.lines) {
           lines.push(`  ${line}`)
@@ -405,6 +425,12 @@ function render(state: State): void {
  * and re-rendering after each step), then transitions to "result" mode.
  * The event loop stays responsive for spinner animation during this time.
  */
+/**
+ * Run delete operations inline within the worktree list.
+ * Stays in browse mode -- each item shows its deletion progress directly
+ * in its row. Completed items are removed from the list after a brief
+ * delay so the user sees the success indicator before it disappears.
+ */
 function startDelete(
   state: State,
   indices: number[],
@@ -412,34 +438,26 @@ function startDelete(
   force: boolean,
   rerender: () => void,
 ): void {
-  // Build progress entries
-  const progress: DeleteProgress[] = indices.map((idx) => {
-    const item = state.items[idx]
-    return {
-      label: item?.worktree.branch ?? item?.worktree.path ?? `index ${idx}`,
-      status: "pending" as const,
+  // Mark items as deleting. Stay in browse mode so the list stays visible.
+  for (const idx of indices) {
+    if (state.items[idx]) {
+      state.items[idx].deleteStatus = { phase: "removing" }
     }
-  })
-
-  state.mode = { type: "deleting", progress, withBranch }
+  }
+  state.selected.clear()
   state.message = null
   rerender()
 
-  // Run the actual deletes in a fire-and-forget async block.
-  // Each step updates progress + re-renders, keeping the TUI alive.
   ;(async () => {
-    const resultLines: string[] = []
     let needsForce = false
 
-    for (let i = 0; i < indices.length; i++) {
-      const idx = indices[i]
+    for (const idx of indices) {
       const item = state.items[idx]
       if (!item) continue
       const wt = item.worktree
-      const entry = progress[i]
 
       // Step 1: remove worktree
-      entry.status = "removing"
+      item.deleteStatus = { phase: "removing" }
       rerender()
 
       const removeResult = await removeWorktree(wt.path, force)
@@ -447,24 +465,17 @@ function startDelete(
       if (removeResult.ok) {
         // Step 2 (optional): delete branch
         if (withBranch && wt.branch) {
-          entry.status = "branch"
+          item.deleteStatus = { phase: "branch" }
           rerender()
 
           const branchResult = await deleteBranch(wt.branch, true)
           if (branchResult.ok) {
-            entry.status = "done"
-            entry.message = "worktree + branch removed"
-            resultLines.push(`${c.green("\u2713")} Removed ${entry.label} + branch`)
+            item.deleteStatus = { phase: "done", message: "worktree + branch removed" }
           } else {
-            entry.status = "done"
-            entry.message = `branch: ${branchResult.error}`
-            resultLines.push(`${c.green("\u2713")} Removed ${entry.label}`)
-            resultLines.push(`${c.red("\u2717")} Branch ${wt.branch}: ${branchResult.error}`)
+            item.deleteStatus = { phase: "done", message: `branch: ${branchResult.error}` }
           }
         } else {
-          entry.status = "done"
-          entry.message = "removed"
-          resultLines.push(`${c.green("\u2713")} Removed ${entry.label}`)
+          item.deleteStatus = { phase: "done", message: "removed" }
         }
       } else {
         const isUncommitted =
@@ -475,39 +486,48 @@ function startDelete(
 
         if (isUncommitted && !force) {
           needsForce = true
-          entry.status = "needs-force"
-          resultLines.push(`${c.yellow("!")} ${entry.label}: has uncommitted changes`)
+          item.deleteStatus = { phase: "needs-force" }
         } else {
-          entry.status = "error"
-          entry.message = removeResult.error
-          resultLines.push(`${c.red("\u2717")} ${entry.label}: ${removeResult.error}`)
+          item.deleteStatus = { phase: "error", message: removeResult.error ?? "unknown error" }
         }
       }
 
       rerender()
     }
 
-    // All items processed. Refresh the worktree list.
-    await refreshWorktrees(state)
-    startPrFetching(state, rerender)
-    startFileStatusFetching(state, rerender)
-    startSizeFetching(state, rerender)
+    // Brief pause so the user can see the final status of each item
+    await Bun.sleep(600)
+
+    // Remove successfully deleted items from the list
+    const removedIndices = new Set(
+      indices.filter((idx) => state.items[idx]?.deleteStatus?.phase === "done"),
+    )
+    // Clear delete status on items that weren't removed (errors, needs-force)
+    for (const idx of indices) {
+      if (state.items[idx] && !removedIndices.has(idx)) {
+        state.items[idx].deleteStatus = null
+      }
+    }
+
+    if (removedIndices.size > 0) {
+      // Rebuild item list without deleted items
+      state.items = state.items.filter((_, i) => !removedIndices.has(i))
+      state.cursor = Math.min(state.cursor, Math.max(0, state.items.length - 1))
+    }
 
     if (needsForce) {
-      state.mode = {
-        type: "result",
-        lines: [
-          ...resultLines,
-          "",
-          `${c.yellow("Some worktrees have uncommitted changes.")}`,
-          `${c.dim("Select them again and press")} ${c.cyan("d")} ${c.dim("to retry with force.")}`,
-        ],
+      state.message = {
+        text: "Some worktrees have uncommitted changes. Select and press d to force.",
+        kind: "error",
+      }
+    } else if (removedIndices.size > 0) {
+      const n = removedIndices.size
+      state.message = {
+        text: `${n} worktree${n > 1 ? "s" : ""} removed.`,
+        kind: "success",
       }
-    } else {
-      state.mode = { type: "result", lines: resultLines }
     }
 
-    state.message = null
     rerender()
   })()
 }
@@ -525,6 +545,9 @@ async function refreshWorktrees(state: State): Promise<void> {
       prStatus: { type: "loading" as const },
       fileStatus: { type: "loading" as const },
       dirSize: { type: "loading" as const },
+      sessionInfo: { type: "loading" as const },
+      parentSession: { type: "loading" as const },
+      deleteStatus: null,
     }))
 
   state.selected.clear()
@@ -664,6 +687,91 @@ function startFileStatusFetching(state: State, rerender: () => void): void {
   })()
 }
 
+// ---------------------------------------------------------------------------
+// Async session info fetching (background, concurrent)
+// ---------------------------------------------------------------------------
+
+const SESSION_CONCURRENCY = 6
+
+/**
+ * Fetch Claude Code session info for all worktrees in background.
+ * Reads local files only (no network), so fast.
+ */
+function startSessionFetching(state: State, rerender: () => void): void {
+  const entries = state.items.map((item, index) => ({
+    path: item.worktree.path,
+    index,
+  }))
+
+  const executing: Promise<void>[] = []
+
+  const fetchOne = async ({ path, index }: { path: string; index: number }) => {
+    try {
+      const result = await fetchWorktreeSessionInfo(path)
+      if (state.items[index]?.worktree.path === path) {
+        state.items[index].sessionInfo = result
+      }
+    } catch {
+      if (state.items[index]?.worktree.path === path) {
+        state.items[index].sessionInfo = { type: "none" }
+      }
+    }
+    rerender()
+  }
+
+  ;(async () => {
+    for (const entry of entries) {
+      const task = fetchOne(entry)
+      executing.push(task)
+      task.then(() => {
+        const idx = executing.indexOf(task)
+        if (idx !== -1) executing.splice(idx, 1)
+      })
+
+      if (executing.length >= SESSION_CONCURRENCY) {
+        await Promise.race(executing)
+      }
+    }
+    await Promise.all(executing)
+  })()
+}
+
+// ---------------------------------------------------------------------------
+// Async parent session detection (background)
+// ---------------------------------------------------------------------------
+
+/**
+ * For each worktree, find the active Claude Code session that created it.
+ * Runs findParentSession() for each worktree concurrently.
+ * Since this involves grepping JSONL files it's the slowest fetch --
+ * runs after the faster fetches have already populated the UI.
+ */
+function startParentSessionFetching(state: State, rerender: () => void): void {
+  const entries = state.items.map((item, index) => ({
+    path: item.worktree.path,
+    index,
+  }))
+
+  // Run all concurrently -- findParentSession already limits grep parallelism internally
+  ;(async () => {
+    await Promise.all(
+      entries.map(async ({ path, index }) => {
+        try {
+          const result = await findParentSession(path)
+          if (state.items[index]?.worktree.path === path) {
+            state.items[index].parentSession = result
+          }
+        } catch {
+          if (state.items[index]?.worktree.path === path) {
+            state.items[index].parentSession = { type: "none" }
+          }
+        }
+        rerender()
+      }),
+    )
+  })()
+}
+
 // ---------------------------------------------------------------------------
 // Async directory size fetching (background, sequential)
 // ---------------------------------------------------------------------------
@@ -701,24 +809,29 @@ function startSizeFetching(state: State, rerender: () => void): void {
 async function handleBrowseKey(state: State, key: Key): Promise<void> {
   const ch = keyChar(key)
 
-  // Navigation (collapse expand on cursor move)
+  // Navigation (collapse expand on cursor move, skip items being deleted)
   if (key === "up" || ch === "k") {
-    state.cursor = Math.max(0, state.cursor - 1)
+    let next = state.cursor - 1
+    while (next >= 0 && state.items[next]?.deleteStatus) next--
+    if (next >= 0) state.cursor = next
     state.expandedIndex = null
     state.expandedFiles = null
     state.message = null
     return
   }
   if (key === "down" || ch === "j") {
-    state.cursor = Math.min(state.items.length - 1, state.cursor + 1)
+    let next = state.cursor + 1
+    while (next < state.items.length && state.items[next]?.deleteStatus) next++
+    if (next < state.items.length) state.cursor = next
     state.expandedIndex = null
     state.expandedFiles = null
     state.message = null
     return
   }
 
-  // Selection
+  // Selection (skip items being deleted)
   if (key === "space") {
+    if (state.items[state.cursor]?.deleteStatus) return
     if (state.selected.has(state.cursor)) {
       state.selected.delete(state.cursor)
     } else {
@@ -793,6 +906,8 @@ async function handleBrowseKey(state: State, key: Key): Promise<void> {
     await refreshWorktrees(state)
     startPrFetching(state, () => render(state))
     startFileStatusFetching(state, () => render(state))
+    startSessionFetching(state, () => render(state))
+    startParentSessionFetching(state, () => render(state))
     startSizeFetching(state, () => render(state))
     state.message = { text: "Refreshed.", kind: "success" }
     return
@@ -838,7 +953,7 @@ async function handleBrowseKey(state: State, key: Key): Promise<void> {
   }
 
   // Quit
-  if (key === "ctrl-c" || ch === "q") {
+  if (key === "ctrl-c" || key === "escape" || ch === "q") {
     state.shouldQuit = true
     return
   }
@@ -900,6 +1015,8 @@ async function handleConfirmPruneKey(state: State, key: Key): Promise<void> {
       await refreshWorktrees(state)
       startPrFetching(state, () => render(state))
       startFileStatusFetching(state, () => render(state))
+      startSessionFetching(state, () => render(state))
+      startParentSessionFetching(state, () => render(state))
       startSizeFetching(state, () => render(state))
       state.mode = {
         type: "result",
@@ -933,13 +1050,21 @@ async function printListAndExit(): Promise<void> {
   console.log(`  ${c.bold(fellLogo())}  ${c.dim("--list")}`)
   console.log()
 
-  // Fetch file statuses for all worktrees concurrently
-  const fileStatuses = await Promise.all(
-    worktrees.map(async (wt) => {
-      if (wt.isBare) return { type: "clean" as const }
-      return fetchWorktreeFileStatus(wt.path)
-    }),
-  )
+  // Fetch file statuses, session info, and parent sessions concurrently
+  const [fileStatuses, sessionInfos, parentSessions] = await Promise.all([
+    Promise.all(
+      worktrees.map(async (wt) => {
+        if (wt.isBare) return { type: "clean" as const }
+        return fetchWorktreeFileStatus(wt.path)
+      }),
+    ),
+    Promise.all(
+      worktrees.map(async (wt) => fetchWorktreeSessionInfo(wt.path)),
+    ),
+    Promise.all(
+      worktrees.map(async (wt) => findParentSession(wt.path)),
+    ),
+  ])
 
   for (let i = 0; i < worktrees.length; i++) {
     const wt = worktrees[i]
@@ -955,8 +1080,12 @@ async function printListAndExit(): Promise<void> {
     let path = wt.path
     if (home && path.startsWith(home)) path = "~" + path.slice(home.length)
 
+    // Inline parent session indicator (orange dot)
+    const parentInline = formatParentSessionInline(parentSessions[i])
+    const parentSuffix = parentInline ? `  ${parentInline}` : ""
+
     console.log(
-      `  ${branch.padEnd(35)} ${c.dim(sha)}  ${c.dim(path)}${tagStr}`,
+      `  ${branch.padEnd(35)} ${c.dim(sha)}  ${c.dim(path)}${tagStr}${parentSuffix}`,
     )
 
     // Sub-line for dirty file status
@@ -964,6 +1093,17 @@ async function printListAndExit(): Promise<void> {
     if (fsLine) {
       console.log(`     ${fsLine}`)
     }
+
+    // Sub-lines for session info + parent session detail (--list shows expanded by default)
+    const cols = process.stdout.columns ?? 100
+    const sessLine = formatSessionInfo(sessionInfos[i], cols - 20)
+    if (sessLine) {
+      console.log(`     ${sessLine}`)
+    }
+    const parentLines = formatParentSessionExpanded(parentSessions[i], cols - 20)
+    for (const pl of parentLines) {
+      console.log(`     ${pl}`)
+    }
   }
 
   // Fetch PR statuses if gh is available
@@ -1027,8 +1167,8 @@ function startSpinnerTimer(
     const hasLoading = state.items.some(
       (i) => i.prStatus.type === "loading" || i.dirSize.type === "loading",
     )
-    const isDeleting = state.mode.type === "deleting"
-    if (hasLoading || isDeleting) {
+    const hasDeleting = state.items.some((i) => i.deleteStatus !== null)
+    if (hasLoading || hasDeleting) {
       state.spinnerFrame =
         (state.spinnerFrame + 1) % SPINNER_FRAMES.length
       rerender()
@@ -1085,6 +1225,9 @@ async function main() {
       prStatus: { type: "loading" },
       fileStatus: { type: "loading" },
       dirSize: { type: "loading" },
+      sessionInfo: { type: "loading" },
+      parentSession: { type: "loading" },
+      deleteStatus: null,
     })),
     mainWorktree,
     cursor: 0,
@@ -1134,9 +1277,11 @@ async function main() {
     // Initial render
     render(state)
 
-    // Start background PR fetching, file status checks, and size estimation
+    // Start background fetching: PR, file status, sessions, parent sessions, size
     startPrFetching(state, () => render(state))
     startFileStatusFetching(state, () => render(state))
+    startSessionFetching(state, () => render(state))
+    startParentSessionFetching(state, () => render(state))
     startSizeFetching(state, () => render(state))
 
     // Start spinner animation timer
@@ -1169,13 +1314,6 @@ async function main() {
           await handleConfirmPruneKey(state, key)
           break
 
-        case "deleting":
-          // Background delete in progress - ignore keys (spinner keeps animating via timer)
-          if (key === "ctrl-c") {
-            state.shouldQuit = true
-          }
-          break
-
         case "result":
           // Any key returns to browse
           state.mode = { type: "browse" }
@@ -1201,6 +1339,10 @@ async function main() {
     clearInterval(spinnerTimer)
   } finally {
     cleanup()
+    // Force exit immediately. Background async tasks (PR fetching, size
+    // estimation) hold the event loop open. They're non-critical UI state
+    // -- no data corruption risk from terminating mid-flight.
+    process.exit(0)
   }
 }
 

package/lib/git.ts

@@ -130,6 +130,10 @@ export async function listWorktrees(): Promise<Worktree[]> {
 /**
  * Remove a worktree directory and its git administrative tracking.
  * Use force when the worktree has uncommitted changes.
+ *
+ * Handles zombie worktrees (directory exists but .git file is missing):
+ * falls back to `git worktree prune` to clean the reference, then
+ * removes the leftover directory manually.
  */
 export async function removeWorktree(
   path: string,
@@ -137,10 +141,29 @@ export async function removeWorktree(
 ): Promise<{ ok: boolean; error?: string }> {
   const flags = force ? ["--force"] : []
   const result = await $`git worktree remove ${flags} ${path}`.nothrow().quiet()
-  if (result.exitCode !== 0) {
-    return { ok: false, error: result.stderr.toString().trim() }
+
+  if (result.exitCode === 0) return { ok: true }
+
+  const stderr = result.stderr.toString().trim()
+
+  // Zombie worktree: directory exists but .git is missing.
+  // git worktree remove refuses to act, so we prune the reference
+  // and remove the leftover directory ourselves.
+  const isZombie =
+    stderr.includes("does not exist") &&
+    (stderr.includes(".git") || stderr.includes("validation failed"))
+
+  if (isZombie) {
+    // Prune cleans the stale git reference
+    await $`git worktree prune`.nothrow().quiet()
+
+    // Remove the leftover directory if it still exists
+    await $`rm -rf ${path}`.nothrow().quiet()
+
+    return { ok: true }
   }
-  return { ok: true }
+
+  return { ok: false, error: stderr }
 }
 
 /**
@@ -412,3 +435,493 @@ export async function fetchPrForBranch(
     return null
   }
 }
+
+// ---------------------------------------------------------------------------
+// Claude Code session lookups
+// ---------------------------------------------------------------------------
+
+export interface SessionInfo {
+  sessionCount: number
+  latestSessionId: string
+  /** First user message content from the most recent session, truncated. */
+  latestPrompt: string
+  /** ISO timestamp from the first user message. */
+  latestTimestamp: string
+}
+
+export type SessionResult =
+  | { type: "loading" }
+  | { type: "found"; info: SessionInfo }
+  | { type: "none" }
+
+/**
+ * Encode an absolute path into Claude Code's project directory name.
+ * Claude replaces all non-alphanumeric characters with `-`,
+ * so `/Users/x/.claude/worktrees/foo` becomes
+ * `-Users-x--claude-worktrees-foo` (`.` and `/` both become `-`).
+ */
+function encodeClaudeProjectPath(absolutePath: string): string {
+  return absolutePath.replace(/[^a-zA-Z0-9]/g, "-")
+}
+
+/**
+ * Extract the first user prompt from a Claude Code session JSONL file.
+ * Reads only the first ~15 lines for performance -- the user message
+ * is almost always within the first few entries.
+ */
+async function extractFirstPrompt(
+  jsonlPath: string,
+): Promise<{ prompt: string; timestamp: string } | null> {
+  try {
+    const content = await Bun.file(jsonlPath).text()
+    const lines = content.split("\n").slice(0, 15)
+
+    for (const line of lines) {
+      if (!line.trim()) continue
+      try {
+        const entry = JSON.parse(line)
+        if (entry.type !== "user") continue
+
+        const rawContent = entry.message?.content
+        let text = ""
+        if (typeof rawContent === "string") {
+          text = rawContent
+        } else if (Array.isArray(rawContent)) {
+          // Array of content blocks: [{ type: "text", text: "..." }, ...]
+          const textBlock = rawContent.find(
+            (b: { type: string }) => b.type === "text",
+          )
+          text = textBlock?.text ?? ""
+        }
+
+        // Strip XML-like tags (e.g. <local-command-caveat>...) that aren't real prompts
+        if (text.startsWith("<")) {
+          // Try to find actual text after tags
+          const stripped = text.replace(/<[^>]+>[^<]*<\/[^>]+>/g, "").trim()
+          if (stripped) text = stripped
+          else continue // skip entries that are purely XML tags
+        }
+
+        // Collapse whitespace/newlines into single spaces for display
+        text = text.trim().replace(/\s+/g, " ")
+        if (!text) continue
+
+        return {
+          prompt: text,
+          timestamp: entry.timestamp ?? "",
+        }
+      } catch {
+        // Skip malformed lines
+      }
+    }
+  } catch {
+    // File read failed
+  }
+  return null
+}
+
+/**
+ * Extract the `cwd` from the first parseable line of a JSONL session file.
+ * Used by the global scanner to recover the original absolute path
+ * without decoding the project directory name (which is lossy).
+ */
+async function extractCwd(jsonlPath: string): Promise<string | null> {
+  try {
+    const content = await Bun.file(jsonlPath).text()
+    for (const line of content.split("\n").slice(0, 10)) {
+      if (!line.trim()) continue
+      try {
+        const entry = JSON.parse(line)
+        if (entry.cwd) return entry.cwd
+      } catch {
+        /* skip malformed */
+      }
+    }
+  } catch {
+    /* file read failed */
+  }
+  return null
+}
+
+// ---------------------------------------------------------------------------
+// Global session scanner
+// ---------------------------------------------------------------------------
+
+/** A single project directory from ~/.claude/projects/ with session metadata. */
+export interface GlobalProjectEntry {
+  /** The original absolute working directory (extracted from JSONL cwd field). */
+  cwd: string
+  /** Whether this is a Claude Code worktree (path contains .claude/worktrees/). */
+  isWorktree: boolean
+  /** The repo root (path before /.claude/worktrees/, or the cwd itself for main repos). */
+  repoRoot: string
+  /** Worktree name (segment after .claude/worktrees/), null for main repo sessions. */
+  worktreeName: string | null
+  /** Number of session JSONL files. */
+  sessionCount: number
+  /** First user prompt from the most recent session. */
+  latestPrompt: string
+  /** ISO timestamp from the most recent session's first user message. */
+  latestTimestamp: string
+}
+
+/** Sessions grouped by repo root. */
+export interface GlobalRepoGroup {
+  repoRoot: string
+  /** Session entry for the main repo (non-worktree), if any. */
+  main: GlobalProjectEntry | null
+  /** Worktree session entries. */
+  worktrees: GlobalProjectEntry[]
+  /** Total sessions across main + all worktrees. */
+  totalSessions: number
+}
+
+/**
+ * Scan ~/.claude/projects/ for all Claude Code sessions across all repos.
+ * Groups results by repo root. Excludes the specified repo (usually the
+ * current repo, which is already shown in the main worktree list).
+ *
+ * Returns empty array if ~/.claude doesn't exist or has no sessions.
+ * Never throws.
+ */
+export async function listGlobalClaudeSessions(
+  excludeRepoRoot?: string,
+): Promise<GlobalRepoGroup[]> {
+  const home = process.env.HOME
+  if (!home) return []
+
+  const projectsDir = `${home}/.claude/projects`
+
+  try {
+    const { readdir, stat } = await import("node:fs/promises")
+    const dirs = await readdir(projectsDir).catch(() => null)
+    if (!dirs || dirs.length === 0) return []
+
+    // Process each project directory concurrently
+    const entries: GlobalProjectEntry[] = []
+    const CONCURRENCY = 8
+    const executing: Promise<void>[] = []
+
+    const processDir = async (dirName: string) => {
+      const dirPath = `${projectsDir}/${dirName}`
+
+      // List JSONL files
+      const files = await readdir(dirPath).catch(() => null)
+      if (!files) return
+      const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"))
+      if (jsonlFiles.length === 0) return
+
+      // Find most recent JSONL by mtime
+      const withMtime = await Promise.all(
+        jsonlFiles.map(async (f) => {
+          const s = await stat(`${dirPath}/${f}`).catch(() => null)
+          return { file: f, mtime: s?.mtimeMs ?? 0 }
+        }),
+      )
+      withMtime.sort((a, b) => b.mtime - a.mtime)
+      const latestFile = withMtime[0].file
+
+      // Extract cwd from the most recent session to get the real path
+      const cwd = await extractCwd(`${dirPath}/${latestFile}`)
+      if (!cwd) return
+
+      // Extract prompt from the most recent session
+      const promptInfo = await extractFirstPrompt(`${dirPath}/${latestFile}`)
+
+      // Determine if this is a worktree session
+      const claudeWtMatch = cwd.match(/^(.+)\/.claude\/worktrees\/([^/]+)/)
+      const cursorWtMatch = cwd.match(
+        /^(.+)\/.cursor\/worktrees\/[^/]+\/([^/]+)/,
+      )
+      const wtMatch = claudeWtMatch ?? cursorWtMatch
+
+      entries.push({
+        cwd,
+        isWorktree: !!wtMatch,
+        repoRoot: wtMatch ? wtMatch[1] : cwd,
+        worktreeName: wtMatch ? wtMatch[2] : null,
+        sessionCount: jsonlFiles.length,
+        latestPrompt: promptInfo?.prompt ?? "",
+        latestTimestamp: promptInfo?.timestamp ?? "",
+      })
+    }
+
+    // Process with concurrency limit
+    for (const dirName of dirs) {
+      const task = processDir(dirName)
+      executing.push(task)
+      task.then(() => {
+        const idx = executing.indexOf(task)
+        if (idx !== -1) executing.splice(idx, 1)
+      })
+      if (executing.length >= CONCURRENCY) {
+        await Promise.race(executing)
+      }
+    }
+    await Promise.all(executing)
+
+    // Group by repo root
+    const groups = new Map<string, GlobalRepoGroup>()
+
+    for (const entry of entries) {
+      // Skip the excluded repo
+      if (excludeRepoRoot && entry.repoRoot === excludeRepoRoot) continue
+
+      let group = groups.get(entry.repoRoot)
+      if (!group) {
+        group = { repoRoot: entry.repoRoot, main: null, worktrees: [], totalSessions: 0 }
+        groups.set(entry.repoRoot, group)
+      }
+
+      group.totalSessions += entry.sessionCount
+
+      if (entry.isWorktree) {
+        group.worktrees.push(entry)
+      } else {
+        group.main = entry
+      }
+    }
+
+    // Sort groups by total session count descending
+    const result = Array.from(groups.values())
+    result.sort((a, b) => b.totalSessions - a.totalSessions)
+
+    // Sort worktrees within each group by session count descending
+    for (const group of result) {
+      group.worktrees.sort((a, b) => b.sessionCount - a.sessionCount)
+    }
+
+    return result
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Look up Claude Code session info for a worktree by reading
+ * `~/.claude/projects/{encoded-path}/` directly.
+ *
+ * Assumption: Claude Code encodes the worktree CWD by replacing `/` with `-`
+ * to form the project directory name. Each `{uuid}.jsonl` file inside is a
+ * session transcript. This is an undocumented internal format and may change.
+ */
+export async function fetchWorktreeSessionInfo(
+  worktreePath: string,
+): Promise<SessionResult> {
+  const home = process.env.HOME
+  if (!home) return { type: "none" }
+
+  const encoded = encodeClaudeProjectPath(worktreePath)
+  const projectDir = `${home}/.claude/projects/${encoded}`
+
+  try {
+    const { readdir, stat } = await import("node:fs/promises")
+    const entries = await readdir(projectDir).catch(() => null)
+    if (!entries) return { type: "none" }
+
+    // Find all .jsonl files (each is a session)
+    const jsonlFiles = entries.filter((e) => e.endsWith(".jsonl"))
+    if (jsonlFiles.length === 0) return { type: "none" }
+
+    // Sort by mtime descending to find the most recent session
+    const withMtime = await Promise.all(
+      jsonlFiles.map(async (f) => {
+        const s = await stat(`${projectDir}/${f}`).catch(() => null)
+        return { file: f, mtime: s?.mtimeMs ?? 0 }
+      }),
+    )
+    withMtime.sort((a, b) => b.mtime - a.mtime)
+
+    const latestFile = withMtime[0].file
+    const latestSessionId = latestFile.replace(".jsonl", "")
+
+    // Extract first user prompt from the most recent session
+    const promptInfo = await extractFirstPrompt(
+      `${projectDir}/${latestFile}`,
+    )
+
+    return {
+      type: "found",
+      info: {
+        sessionCount: jsonlFiles.length,
+        latestSessionId,
+        latestPrompt: promptInfo?.prompt ?? "",
+        latestTimestamp: promptInfo?.timestamp ?? "",
+      },
+    }
+  } catch {
+    return { type: "none" }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Parent session association (worktree <-> spawning session)
+// ---------------------------------------------------------------------------
+
+/*
+ * FLOW DIAGRAM: How we match a worktree to the Claude Code session that created it
+ *
+ *   ~/.claude/sessions/
+ *   ├── 15746.json  ─────────┐
+ *   ├── 51087.json            │  Step 1: List active session PIDs
+ *   └── 71924.json            │          Read each JSON for { sessionId, cwd }
+ *                             │
+ *                             ▼
+ *   ┌─────────────────────────────────────────┐
+ *   │  Active Session Registry                │
+ *   │                                         │
+ *   │  PID 15746                              │
+ *   │    sessionId: 4491a274-...              │
+ *   │    cwd: /Users/x/code/medlo             │
+ *   │                                         │
+ *   │  PID 51087                              │
+ *   │    sessionId: e3408292-...              │
+ *   │    cwd: /Users/x/code/medlo/            │
+ *   │         .claude/worktrees/evo           │
+ *   └──────────────┬──────────────────────────┘
+ *                  │
+ *                  │  Step 2: For each session, locate its JSONL transcript
+ *                  │          at ~/.claude/projects/{encode(cwd)}/{sessionId}.jsonl
+ *                  ▼
+ *   ~/.claude/projects/-Users-x-code-medlo/
+ *   └── 4491a274-....jsonl  ◄── Full conversation transcript (JSONL)
+ *                  │
+ *                  │  Step 3: grep the JSONL for each worktree path
+ *                  │          e.g. ".worktrees/session-column"
+ *                  │          (matches Bash tool calls like
+ *                  │           `git worktree add .worktrees/session-column`)
+ *                  ▼
+ *   ┌─────────────────────────────────────────┐
+ *   │  MATCH FOUND                            │
+ *   │                                         │
+ *   │  Session 4491a274 (cwd: ~/code/medlo)   │
+ *   │  contains ".worktrees/session-column"   │
+ *   │  in its transcript                      │
+ *   │                                         │
+ *   │  → This session CREATED the worktree    │
+ *   └─────────────────────────────────────────┘
+ *
+ * WHY only active sessions:
+ *   - ~/.claude/sessions/ only contains PIDs of RUNNING Claude Code processes
+ *   - Completed sessions are removed from this registry
+ *   - Scanning all historical sessions (121+ files, 185MB+) would be too slow
+ *   - Active sessions are the most useful: "who is working in this worktree right now?"
+ *
+ * WHY grep instead of JSON parsing:
+ *   - JSONL files can be 5MB+ per session (this conversation alone is ~5.5MB)
+ *   - grep -l short-circuits on first match (doesn't read the whole file)
+ *   - We only need to know IF the path appears, not WHERE or HOW
+ *   - Bun's $ shell handles the subprocess efficiently
+ *
+ * PERFORMANCE:
+ *   - Typically 5-15 active sessions
+ *   - Each grep -l takes ~50-400ms depending on file size
+ *   - Total: <2s for all active sessions, runs in background
+ *   - Falls back gracefully if ~/.claude doesn't exist
+ */
+
+/** A Claude Code session that spawned or references a worktree. */
+export interface ParentSession {
+  /** The session UUID. */
+  sessionId: string
+  /** The working directory of the session (typically the main repo, not the worktree). */
+  cwd: string
+  /** First user prompt from the session, for identification. */
+  prompt: string
+}
+
+export type ParentSessionResult =
+  | { type: "loading" }
+  | { type: "found"; session: ParentSession }
+  | { type: "none" }
+
+/**
+ * Find the active Claude Code session that created or references a worktree.
+ *
+ * Scans `~/.claude/sessions/*.json` for running sessions, then greps each
+ * session's JSONL transcript for the worktree path. Returns the first match.
+ *
+ * @param worktreePath - Absolute path to the worktree directory
+ * @returns The parent session if found, or `{ type: "none" }` if no active
+ *          session references this worktree. Never throws.
+ */
+export async function findParentSession(
+  worktreePath: string,
+): Promise<ParentSessionResult> {
+  const home = process.env.HOME
+  if (!home) return { type: "none" }
+
+  const sessionsDir = `${home}/.claude/sessions`
+  const projectsDir = `${home}/.claude/projects`
+
+  // Extract just the worktree-specific suffix for grep matching.
+  // e.g. "/Users/x/code/fell/.worktrees/session-column" -> ".worktrees/session-column"
+  // This is more robust than grepping the full absolute path, which may appear
+  // in different forms (with/without trailing slash, relative, etc.)
+  const wtSuffix = worktreePath.match(/\.worktrees\/[^/]+$/)?.[0]
+    ?? worktreePath.match(/\.claude\/worktrees\/[^/]+$/)?.[0]
+  if (!wtSuffix) return { type: "none" }
+
+  try {
+    const { readdir } = await import("node:fs/promises")
+    const sessionFiles = await readdir(sessionsDir).catch(() => null)
+    if (!sessionFiles) return { type: "none" }
+
+    // Step 1: Read all active session metadata
+    const activeSessions: Array<{
+      sessionId: string
+      cwd: string
+      jsonlPath: string
+    }> = []
+
+    for (const file of sessionFiles) {
+      if (!file.endsWith(".json")) continue
+      try {
+        const raw = await Bun.file(`${sessionsDir}/${file}`).json()
+        const sid = raw?.sessionId as string | undefined
+        const cwd = raw?.cwd as string | undefined
+        if (!sid || !cwd) continue
+
+        const encoded = encodeClaudeProjectPath(cwd)
+        const jsonlPath = `${projectsDir}/${encoded}/${sid}.jsonl`
+
+        // Only include if the JSONL file exists
+        if (await Bun.file(jsonlPath).exists()) {
+          activeSessions.push({ sessionId: sid, cwd, jsonlPath })
+        }
+      } catch {
+        /* skip unreadable session files */
+      }
+    }
+
+    if (activeSessions.length === 0) return { type: "none" }
+
+    // Step 2: grep each session's JSONL for the worktree path.
+    // Run concurrently -- each grep -l short-circuits on first match.
+    const grepResults = await Promise.all(
+      activeSessions.map(async (session) => {
+        const result = await $`grep -l ${wtSuffix} ${session.jsonlPath}`
+          .nothrow()
+          .quiet()
+        return { session, matched: result.exitCode === 0 }
+      }),
+    )
+
+    const match = grepResults.find((r) => r.matched)
+    if (!match) return { type: "none" }
+
+    // Step 3: Extract the first user prompt from the matched session for display
+    const promptInfo = await extractFirstPrompt(match.session.jsonlPath)
+
+    return {
+      type: "found",
+      session: {
+        sessionId: match.session.sessionId,
+        cwd: match.session.cwd,
+        prompt: promptInfo?.prompt ?? "",
+      },
+    }
+  } catch {
+    return { type: "none" }
+  }
+}

package/lib/tui.ts

@@ -4,7 +4,7 @@
  * and the help screen content.
  */
 
-import type { PrStatus, FileStatusResult } from "./git"
+import type { PrStatus, FileStatusResult, SessionResult, GlobalRepoGroup, ParentSessionResult } from "./git"
 
 // ---------------------------------------------------------------------------
 // ANSI escape helpers
@@ -237,6 +237,181 @@ export function formatFileStatus(result: FileStatusResult): string | null {
   return `${c.yellow("\u26A0")} ${parts.join(c.dim("  \u00B7  "))}`
 }
 
+// ---------------------------------------------------------------------------
+// Session info formatting
+// ---------------------------------------------------------------------------
+
+/**
+ * Render a Claude Code session sub-line for a worktree.
+ * Returns null if no sessions or still loading.
+ */
+export function formatSessionInfo(
+  result: SessionResult,
+  maxPromptWidth: number,
+): string | null {
+  if (result.type !== "found") return null
+
+  const { sessionCount, latestPrompt } = result.info
+  const s = sessionCount === 1 ? "session" : "sessions"
+  const count = c.dim(`${sessionCount} ${s}`)
+
+  if (!latestPrompt) {
+    return `${c.dim("\u25C8")} ${count}`
+  }
+
+  const prompt = truncate(latestPrompt, maxPromptWidth)
+  return `${c.dim("\u25C8")} ${count} ${c.dim("\u00B7")} ${c.dim(c.italic(`"${prompt}"`))}`
+}
+
+// ---------------------------------------------------------------------------
+// Parent session formatting
+// ---------------------------------------------------------------------------
+
+/** Orange 256-colour code for Claude/session indicators. */
+const orange = (s: string) => `\x1b[38;5;208m${s}\x1b[0m`
+
+/**
+ * Render an inline orange dot indicator for worktrees with an active parent session.
+ * Shown on the main row (not a sub-line). Returns empty string if no parent session.
+ */
+export function formatParentSessionInline(result: ParentSessionResult): string {
+  if (result.type !== "found") return ""
+  return orange("\u25CF") + " " + c.dim("session")
+}
+
+/**
+ * Render expanded parent session detail lines (shown when user presses "e").
+ * Includes the parent session's CWD and prompt summary.
+ */
+export function formatParentSessionExpanded(
+  result: ParentSessionResult,
+  maxWidth: number,
+): string[] {
+  if (result.type !== "found") return []
+
+  const { cwd, prompt } = result.session
+  const home = process.env.HOME ?? ""
+  let cwdDisplay = cwd
+  if (home && cwdDisplay.startsWith(home)) {
+    cwdDisplay = "~" + cwdDisplay.slice(home.length)
+  }
+
+  const lines: string[] = []
+  const label = `${orange("\u25CF")} ${c.dim("session")} ${c.dim("\u00B7")} ${c.dim(truncate(cwdDisplay, 35))}`
+
+  if (prompt) {
+    lines.push(`${label} ${c.dim("\u00B7")} ${c.dim(c.italic(`"${truncate(prompt, maxWidth - 50)}"`))}`)
+  } else {
+    lines.push(label)
+  }
+
+  return lines
+}
+
+// ---------------------------------------------------------------------------
+// Global session rendering
+// ---------------------------------------------------------------------------
+
+/**
+ * Render the "other repos" global session section for the TUI.
+ * Shows a compact summary of sessions grouped by repo.
+ */
+export function renderGlobalSessionLines(
+  groups: GlobalRepoGroup[],
+  maxWidth: number,
+): string[] {
+  if (groups.length === 0) return []
+
+  const totalRepos = groups.length
+  const totalWorktrees = groups.reduce((sum, g) => sum + g.worktrees.length, 0)
+  const totalSessions = groups.reduce((sum, g) => sum + g.totalSessions, 0)
+
+  const lines: string[] = []
+  lines.push("")
+  lines.push(
+    `  ${c.dim(`${totalRepos} other repo${totalRepos === 1 ? "" : "s"}`)} ${c.dim("\u00B7")} ${c.dim(`${totalWorktrees} worktree${totalWorktrees === 1 ? "" : "s"}`)} ${c.dim("\u00B7")} ${c.dim(`${totalSessions} session${totalSessions === 1 ? "" : "s"}`)}`,
+  )
+
+  for (const group of groups) {
+    const home = process.env.HOME ?? ""
+    let repoDisplay = group.repoRoot
+    if (home && repoDisplay.startsWith(home)) {
+      repoDisplay = "~" + repoDisplay.slice(home.length)
+    }
+
+    const wtCount = group.worktrees.length
+    const sessCount = group.totalSessions
+
+    lines.push(
+      `    ${c.dim(truncate(repoDisplay, maxWidth - 30))}  ${c.dim(`${wtCount} wt`)} ${c.dim("\u00B7")} ${c.dim(`${sessCount} sess`)}`,
+    )
+
+    // Show worktrees with their latest prompt (compact)
+    for (const wt of group.worktrees.slice(0, 3)) {
+      const name = wt.worktreeName ?? "main"
+      const prompt = wt.latestPrompt
+        ? ` ${c.dim("\u00B7")} ${c.dim(c.italic(`"${truncate(wt.latestPrompt, maxWidth - 40)}"`))}`
+        : ""
+      lines.push(
+        `      ${c.dim("\u25C8")} ${c.dim(name)}${prompt}`,
+      )
+    }
+    if (group.worktrees.length > 3) {
+      lines.push(`      ${c.dim(`... ${group.worktrees.length - 3} more`)}`)
+    }
+  }
+
+  return lines
+}
+
+/**
+ * Render global sessions for --list mode (more expanded than TUI).
+ */
+export function printGlobalSessions(groups: GlobalRepoGroup[]): void {
+  if (groups.length === 0) return
+
+  console.log()
+  console.log(`  ${c.dim("OTHER REPOS")}`)
+  console.log()
+
+  for (const group of groups) {
+    const home = process.env.HOME ?? ""
+    let repoDisplay = group.repoRoot
+    if (home && repoDisplay.startsWith(home)) {
+      repoDisplay = "~" + repoDisplay.slice(home.length)
+    }
+
+    const parts: string[] = []
+    if (group.worktrees.length > 0) {
+      parts.push(`${group.worktrees.length} worktree${group.worktrees.length === 1 ? "" : "s"}`)
+    }
+    parts.push(`${group.totalSessions} session${group.totalSessions === 1 ? "" : "s"}`)
+
+    console.log(`  ${c.dim(repoDisplay)}  ${c.dim(`(${parts.join(", ")})`)}`)
+
+    // Main repo sessions
+    if (group.main && group.main.sessionCount > 0) {
+      const prompt = group.main.latestPrompt
+        ? `  ${c.dim(c.italic(`"${truncate(group.main.latestPrompt, 60)}"`))}`
+        : ""
+      console.log(
+        `    ${c.dim("\u25C8")} ${c.dim("main")} ${c.dim("\u00B7")} ${c.dim(`${group.main.sessionCount} session${group.main.sessionCount === 1 ? "" : "s"}`)}${prompt}`,
+      )
+    }
+
+    // Worktree sessions
+    for (const wt of group.worktrees) {
+      const name = wt.worktreeName ?? "unknown"
+      const prompt = wt.latestPrompt
+        ? `  ${c.dim(c.italic(`"${truncate(wt.latestPrompt, 60)}"`))}`
+        : ""
+      console.log(
+        `    ${c.dim("\u25C8")} ${c.dim(name)} ${c.dim("\u00B7")} ${c.dim(`${wt.sessionCount} session${wt.sessionCount === 1 ? "" : "s"}`)}${prompt}`,
+      )
+    }
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Help screen
 // ---------------------------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doccy/fell",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Interactive git worktree manager. Navigate, inspect, delete, and prune worktrees with async PR status fetching.",
   "license": "MIT",
   "bin": {