@ucsandman/legcli 0.9.0 → 0.10.0

package/src/history/providers/claude.mjs

@@ -0,0 +1,161 @@
+// Claude Code discovery — what `~/.claude` (CLAUDE_CONFIG_DIR) keeps, read only.
+// Observed live, Claude Code 2.1.237–2.1.273 (2026-09-16, 798 transcripts):
+//   projects/<encoded cwd>/<sessionId>.jsonl   one transcript per session. Only
+//     user/assistant/attachment/system lines carry cwd, gitBranch, sessionId,
+//     version and timestamp; control lines carry type + sessionId + payload:
+//     `custom-title` {customTitle} and `ai-title` {aiTitle} (repeated as the
+//     title changes, the LAST one is current), `worktree-state`
+//     {worktreeSession:{originalCwd, worktreePath, worktreeBranch, originalBranch}},
+//     `history-suppression` (Claude Code hides that session itself). Sidechain
+//     (subagent) lines and the <sessionId>/ directory beside the file
+//     (subagents/, tool-results/) are not the conversation and are not listed.
+//   history.jsonl        {display, timestamp, project, sessionId} per prompt:
+//     the cheap turn count and the fallback title, one pass, keyed by sessionId.
+//   sessions/<pid>.json  {pid, sessionId, cwd, status} for a running process:
+//     the only "is it live" signal, and it goes stale, so the pid is checked.
+// The project directory name is Claude's own (lossy) encoding of the cwd and
+// is never decoded here: the cwd comes from the transcript lines themselves.
+import { join } from 'node:path'
+import { LAYOUT } from '../../accounts.mjs'
+import { pidAlive } from '../../sessions.mjs'
+import { messagesFromLines } from '../../taps/claude.mjs'
+import { readHead, readTail, jsonLines, line, isoOrNull, isoFromMs, safeList, safeStat, safeRead, PROMPT_MAX } from '../common.mjs'
+
+export const name = 'claude'
+export const label = 'Claude Code'
+export const ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+export function root(homes = {}) { return homes.claude ?? LAYOUT.claude.home() }
+
+function textOf(content) {
+  if (typeof content === 'string') return content
+  if (Array.isArray(content)) return content.filter((c) => c?.type === 'text' && c.text).map((c) => c.text).join('\n')
+  return ''
+}
+
+// One transcript's metadata from its head and tail; null when the file is not
+// a conversation (no line names a session).
+function parseTranscript(path, st) {
+  const head = jsonLines(readHead(path))
+  const tail = jsonLines(readTail(path))
+  let sessionId = null; let cwd = null; let branch = null; let version = null; let startedAt = null; let firstPrompt = null
+  const titles = { custom: null, ai: null }
+  let worktree = null; let hidden = false
+  const control = (j) => {
+    if (j.type === 'custom-title' && typeof j.customTitle === 'string') titles.custom = line(j.customTitle)
+    else if (j.type === 'ai-title' && typeof j.aiTitle === 'string') titles.ai = line(j.aiTitle)
+    else if (j.type === 'worktree-state' && j.worktreeSession && typeof j.worktreeSession.worktreePath === 'string') worktree = { path: j.worktreeSession.worktreePath, branch: j.worktreeSession.worktreeBranch ?? null, original_cwd: j.worktreeSession.originalCwd ?? null, original_branch: j.worktreeSession.originalBranch ?? null }
+    else if (j.type === 'history-suppression') hidden = true
+  }
+  for (const j of head) {
+    if (!sessionId && typeof j.sessionId === 'string') sessionId = j.sessionId
+    control(j)
+    if (j.type !== 'user' && j.type !== 'assistant') continue
+    if (j.isSidechain) continue
+    if (!cwd && typeof j.cwd === 'string') cwd = j.cwd
+    if (!branch && typeof j.gitBranch === 'string' && j.gitBranch) branch = j.gitBranch
+    if (!version && typeof j.version === 'string') version = j.version
+    if (!startedAt && j.timestamp) startedAt = isoOrNull(j.timestamp)
+    if (!firstPrompt && j.type === 'user') {
+      const text = textOf(j.message?.content).trim()
+      if (text && !/^<[a-z-]+>/.test(text)) firstPrompt = line(text, PROMPT_MAX)
+    }
+  }
+  // the tail is where the current title and the latest worktree move sit
+  for (const j of tail) control(j)
+  if (!sessionId) return null
+  let updatedAt = null
+  for (const j of [...tail].reverse()) { if (j.timestamp) { updatedAt = isoOrNull(j.timestamp); if (updatedAt) break } }
+  return {
+    native_id: sessionId,
+    cwd, branch,
+    title: titles.custom ?? titles.ai ?? firstPrompt ?? null,
+    started_at: startedAt ?? isoFromMs(st.birthtimeMs) ?? isoFromMs(st.mtimeMs),
+    updated_at: updatedAt ?? isoFromMs(st.mtimeMs),
+    transcript_path: path,
+    size_bytes: st.size,
+    native: { version, kind: 'transcript', hidden, worktree },
+  }
+}
+
+// history.jsonl → prompts per session (count, first display), re-read only
+// when the file changed.
+function promptIndex(home, prev) {
+  const f = join(home, 'history.jsonl')
+  const st = safeStat(f)
+  if (!st) return { key: null, map: {} }
+  const key = `${st.mtimeMs}:${st.size}`
+  if (prev?.key === key) return prev
+  const map = {}
+  for (const j of jsonLines(safeRead(f))) {
+    if (typeof j.sessionId !== 'string') continue
+    const cur = map[j.sessionId] ?? (map[j.sessionId] = { count: 0, first: null })
+    cur.count += 1
+    if (!cur.first && typeof j.display === 'string' && j.display && !j.display.startsWith('/') && !j.display.startsWith('[Pasted')) cur.first = line(j.display, PROMPT_MAX)
+  }
+  return { key, map }
+}
+
+// sessions/<pid>.json → id → status for every process still alive.
+export function liveIds(home) {
+  const out = new Map()
+  for (const d of safeList(join(home, 'sessions'))) {
+    if (!d.isFile() || !d.name.endsWith('.json')) continue
+    const j = (() => { try { return JSON.parse(safeRead(join(home, 'sessions', d.name)) ?? '') } catch { return null } })()
+    if (j && typeof j.sessionId === 'string' && pidAlive(j.pid)) out.set(j.sessionId, typeof j.status === 'string' ? j.status : 'busy')
+  }
+  return out
+}
+
+// { entries: { [transcript path]: { mtime, size, record } }, aux, scanned, parsed }
+export function scan({ home, prev = {} }) {
+  const projects = join(home, 'projects')
+  const entries = {}
+  let scanned = 0; let parsed = 0
+  const before = prev.entries ?? {}
+  for (const dir of safeList(projects)) {
+    if (!dir.isDirectory()) continue // a junction or symlink is never followed
+    const pdir = join(projects, dir.name)
+    for (const f of safeList(pdir)) {
+      if (!f.isFile() || !f.name.endsWith('.jsonl')) continue
+      const path = join(pdir, f.name)
+      const st = safeStat(path)
+      if (!st) continue
+      scanned += 1
+      const old = before[path]
+      if (old && old.mtime === st.mtimeMs && old.size === st.size) { entries[path] = old; continue }
+      const record = parseTranscript(path, st)
+      parsed += 1
+      if (record) entries[path] = { mtime: st.mtimeMs, size: st.size, record }
+    }
+  }
+  const prompts = promptIndex(home, prev.aux?.prompts)
+  const live = liveIds(home)
+  for (const e of Object.values(entries)) {
+    const r = e.record
+    const p = prompts.map[r.native_id]
+    r.turns = p?.count ?? null
+    if (!r.title && p?.first) r.title = p.first
+    r.live = live.has(r.native_id)
+    r.native.status = live.get(r.native_id) ?? null
+  }
+  return { entries, aux: { prompts }, scanned, parsed }
+}
+
+// The last messages, from the tail of the file only: a transcript can run to
+// tens of megabytes and the drawer wants eight lines of it.
+export function messages(record, limit = 8) {
+  const text = readTail(record.transcript_path, 4 * 1024 * 1024)
+  return messagesFromLines(text.split('\n'), limit)
+}
+
+// `claude --resume <session-id>` (claude --help, 2.1.273: "-r, --resume [value]
+// Resume a conversation by session ID"). The picker filters by cwd, and the
+// id form does not, but the conversation's files live in its cwd, so that is
+// where Leg starts it.
+export function resume(record) {
+  if (!ID_RE.test(record.native_id)) return { supported: false, reason: 'the session id is not one claude --resume accepts' }
+  return { supported: true, agent: 'claude', args: ['--resume', record.native_id] }
+}
+
+export const transcript = 'supported'

package/src/history/providers/codex.mjs

@@ -0,0 +1,133 @@
+// Codex discovery — what `~/.codex` (CODEX_HOME) keeps, read only.
+// Observed live, codex-cli 0.84.0–0.154.0 (2026-09-16, 358 rollouts):
+//   sessions/YYYY/MM/DD/rollout-<local stamp>-<uuid>.jsonl   one thread per file;
+//     the first line is session_meta {id (this thread), session_id (the root
+//     thread), cwd, timestamp (UTC), cli_version, originator, source, thread_source,
+//     git {branch, commit_hash, repository_url}} (src/taps/codex.mjs readMeta
+//     reads it bounded). A subagent thread has source {subagent: {...}} (older
+//     versions: thread_source "subagent") and is listed only on request.
+//     `base_instructions.text` is the system prompt and never surfaces.
+//   session_index.jsonl  {id, thread_name, updated_at}: the title Codex gave
+//     (sparse: not every thread is in it).
+//   history.jsonl        {session_id, ts (seconds), text} per prompt: the turn count.
+// Codex keeps no "live" marker Leg can read; `live` stays null (unknown).
+import { join } from 'node:path'
+import { LAYOUT } from '../../accounts.mjs'
+import { readMeta, parseLines } from '../../taps/codex.mjs'
+import { readHead, readTail, jsonLines, line, isoOrNull, isoFromMs, safeList, safeStat, safeRead, PROMPT_MAX } from '../common.mjs'
+
+export const name = 'codex'
+export const label = 'Codex'
+export const ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+export function root(homes = {}) { return homes.codex ?? LAYOUT.codex.home() }
+
+// only what a human said and what the agent answered: a `developer` message
+// is injected harness text (AGENTS.md, model notices), never shown
+function conversationLines(lines) {
+  return lines.filter((l) => {
+    if (!l.includes('"role"')) return true
+    try { const j = JSON.parse(l); const p = j.payload ?? {}; return !(j.type === 'response_item' && p.type === 'message' && p.role !== 'user' && p.role !== 'assistant') } catch { return false }
+  })
+}
+
+function parseRollout(path, st) {
+  const headText = readHead(path)
+  let meta = readMeta(path)
+  if (!meta) { // a BOM or a torn first line: try the bounded head ourselves
+    const first = jsonLines(headText.split('\n')[0] ?? '')[0]
+    meta = first?.type === 'session_meta' ? first.payload : null
+  }
+  if (!meta || typeof meta.id !== 'string') return null
+  const parsed = parseLines(conversationLines(headText.split('\n').slice(1)))
+  const first = parsed.messages.find((m) => m.role === 'user')
+  let updatedAt = null
+  for (const j of jsonLines(readTail(path)).reverse()) { if (j.timestamp) { updatedAt = isoOrNull(j.timestamp); if (updatedAt) break } }
+  const subagent = (typeof meta.source === 'object' && meta.source !== null && Boolean(meta.source.subagent)) || meta.thread_source === 'subagent'
+  return {
+    native_id: meta.id,
+    cwd: typeof meta.cwd === 'string' ? meta.cwd : null,
+    branch: typeof meta.git?.branch === 'string' ? meta.git.branch : null,
+    title: first ? line(first.text, PROMPT_MAX) : null, // session_index wins below when it names this thread
+    started_at: isoOrNull(meta.timestamp) ?? isoFromMs(st.birthtimeMs) ?? isoFromMs(st.mtimeMs),
+    updated_at: updatedAt ?? isoFromMs(st.mtimeMs),
+    transcript_path: path,
+    size_bytes: st.size,
+    native: {
+      version: meta.cli_version ?? null, originator: meta.originator ?? null, kind: subagent ? 'subagent' : 'thread', subagent,
+      root_id: typeof meta.session_id === 'string' ? meta.session_id : null,
+      parent_id: meta.parent_thread_id ?? meta.source?.subagent?.thread_spawn?.parent_thread_id ?? null,
+      commit: meta.git?.commit_hash ?? null, remote: meta.git?.repository_url ?? null,
+    },
+  }
+}
+
+function fileIndex(f, prev, fold) {
+  const st = safeStat(f)
+  if (!st) return { key: null, map: {} }
+  const key = `${st.mtimeMs}:${st.size}`
+  if (prev?.key === key) return prev
+  const map = {}
+  for (const j of jsonLines(safeRead(f))) fold(map, j)
+  return { key, map }
+}
+
+export function scan({ home, prev = {} }) {
+  const root = join(home, 'sessions')
+  const entries = {}
+  let scanned = 0; let parsed = 0
+  const before = prev.entries ?? {}
+  const digits = (d) => d.isDirectory() && /^\d+$/.test(d.name)
+  for (const y of safeList(root).filter(digits)) {
+    for (const m of safeList(join(root, y.name)).filter(digits)) {
+      for (const d of safeList(join(root, y.name, m.name)).filter(digits)) {
+        const dir = join(root, y.name, m.name, d.name)
+        for (const f of safeList(dir)) {
+          if (!f.isFile() || !f.name.startsWith('rollout-') || !f.name.endsWith('.jsonl')) continue
+          const path = join(dir, f.name)
+          const st = safeStat(path)
+          if (!st) continue
+          scanned += 1
+          const old = before[path]
+          if (old && old.mtime === st.mtimeMs && old.size === st.size) { entries[path] = old; continue }
+          const record = parseRollout(path, st)
+          parsed += 1
+          if (record) entries[path] = { mtime: st.mtimeMs, size: st.size, record }
+        }
+      }
+    }
+  }
+  const titles = fileIndex(join(home, 'session_index.jsonl'), prev.aux?.titles, (map, j) => { if (typeof j.id === 'string' && typeof j.thread_name === 'string') map[j.id] = line(j.thread_name) })
+  const turns = fileIndex(join(home, 'history.jsonl'), prev.aux?.turns, (map, j) => { if (typeof j.session_id === 'string') map[j.session_id] = (map[j.session_id] ?? 0) + 1 })
+  for (const e of Object.values(entries)) {
+    const r = e.record
+    if (titles.map[r.native_id]) r.title = titles.map[r.native_id]
+    r.turns = turns.map[r.native_id] ?? null
+    r.live = null
+  }
+  return { entries, aux: { titles, turns }, scanned, parsed }
+}
+
+export function messages(record, limit = 8) {
+  const text = readTail(record.transcript_path, 4 * 1024 * 1024)
+  // task_complete repeats the last agent message the response_item already
+  // carried: one turn, one row
+  const out = []
+  for (const m of parseLines(conversationLines(text.split('\n').filter(Boolean))).messages) {
+    const prev = out[out.length - 1]
+    if (prev && prev.role === m.role && prev.text === m.text) continue
+    out.push(m)
+  }
+  return out.slice(-limit)
+}
+
+// `codex resume <SESSION_ID>` (codex resume --help, 0.154.0: "Session id (UUID)
+// or session name"; an explicit id bypasses the cwd-filtered picker). A
+// subagent thread is not a session a human can resume.
+export function resume(record) {
+  if (record.native?.subagent) return { supported: false, reason: 'a subagent thread belongs to the thread that spawned it' }
+  if (!ID_RE.test(record.native_id)) return { supported: false, reason: 'the thread id is not one codex resume accepts' }
+  return { supported: true, agent: 'codex', args: ['resume', record.native_id] }
+}
+
+export const transcript = 'supported'

package/src/history/providers/copilot.mjs

@@ -0,0 +1,94 @@
+// GitHub Copilot CLI discovery — what `~/.copilot` keeps, read only. Copilot
+// is a provider Leg can DISCOVER without being one it can supervise or hand
+// off to: it lists here, its transcript reads here, and `continue` says no.
+// Observed live, copilot 1.0.80 (2026-09-16):
+//   session-state/<sessionId>/workspace.yaml   flat `key: value` lines: id, cwd,
+//     git_root, repository, branch, name, user_named, created_at, updated_at
+//   session-state/<sessionId>/events.jsonl     {type, data, id, timestamp, parentId};
+//     user.message {data.content} and assistant.message {data.content} are the
+//     conversation; session.start.data.context carries cwd, gitRoot, branch
+//   session.db beside them is SQLite and is not opened.
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+import { readTail, jsonLines, line, isoOrNull, isoFromMs, safeList, safeStat, safeRead } from '../common.mjs'
+
+export const name = 'copilot'
+export const label = 'Copilot CLI'
+export const ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+export function root(homes = {}) { return homes.copilot ?? process.env.COPILOT_HOME ?? join(homedir(), '.copilot') }
+
+// the flat YAML copilot writes: one `key: value` per line, no nesting, no quoting
+function flatYaml(text) {
+  const out = {}
+  for (const raw of String(text ?? '').split(/\r?\n/)) {
+    const m = /^([A-Za-z0-9_]+):\s*(.*)$/.exec(raw)
+    if (m) out[m[1]] = m[2].replace(/^["']|["']$/g, '')
+  }
+  return out
+}
+
+function parseSession(dir, st) {
+  const y = flatYaml(safeRead(join(dir, 'workspace.yaml')))
+  if (typeof y.id !== 'string' || !y.id) return null
+  const events = join(dir, 'events.jsonl')
+  const est = safeStat(events)
+  return {
+    native_id: y.id,
+    cwd: y.cwd || null,
+    branch: y.branch || null,
+    title: line(y.name ?? '') || null,
+    started_at: isoOrNull(y.created_at) ?? isoFromMs(st.birthtimeMs) ?? isoFromMs(st.mtimeMs),
+    updated_at: isoOrNull(y.updated_at) ?? isoFromMs(est?.mtimeMs) ?? isoFromMs(st.mtimeMs),
+    transcript_path: est ? events : null,
+    size_bytes: est?.size ?? 0,
+    turns: null,
+    live: null,
+    native: { version: null, kind: 'session', repository: y.repository || null, git_root: y.git_root || null, user_named: y.user_named === 'true' },
+  }
+}
+
+export function scan({ home, prev = {} }) {
+  const root = join(home, 'session-state')
+  const entries = {}
+  let scanned = 0; let parsed = 0
+  const before = prev.entries ?? {}
+  for (const d of safeList(root)) {
+    if (!d.isDirectory()) continue
+    const dir = join(root, d.name)
+    const ws = join(dir, 'workspace.yaml')
+    const st = safeStat(ws)
+    if (!st) continue
+    scanned += 1
+    const old = before[ws]
+    // the yaml's updated_at moves with the session, so its stat is the key
+    if (old && old.mtime === st.mtimeMs && old.size === st.size) { entries[ws] = old; continue }
+    const record = parseSession(dir, st)
+    parsed += 1
+    if (record) entries[ws] = { mtime: st.mtimeMs, size: st.size, record }
+  }
+  return { entries, aux: {}, scanned, parsed }
+}
+
+export function messagesFromLines(lines, limit = 8) {
+  const out = []
+  for (const j of jsonLines(lines.join('\n'))) {
+    if (j.type !== 'user.message' && j.type !== 'assistant.message') continue
+    const text = String(j.data?.content ?? '').trim()
+    if (!text) continue
+    out.push({ role: j.type === 'user.message' ? 'user' : 'assistant', text: text.slice(0, 1500), ts: j.timestamp ?? null })
+  }
+  return out.slice(-limit)
+}
+
+export function messages(record, limit = 8) {
+  if (!record.transcript_path) return []
+  return messagesFromLines(readTail(record.transcript_path, 4 * 1024 * 1024).split('\n'), limit)
+}
+
+// copilot --help (1.0.80) has --continue (the most recent session) and
+// --connect[=sessionId] (a remote session); no resume-by-id Leg has verified,
+// and copilot is not an agent `leg <agent>` supervises.
+export function resume() { return { supported: false, reason: 'copilot is not an agent Leg supervises, and no resume-by-id flag is verified' } }
+
+export const transcript = 'supported'

package/src/history/providers/grok.mjs

@@ -0,0 +1,138 @@
+// Grok discovery — what `~/.grok` (GROK_HOME) keeps, read only.
+// Observed live, grok 4.6 build CLI (2026-09-16):
+//   sessions/<url-encoded cwd>/<session-id>/summary.json   {info:{id,cwd},
+//     created_at, updated_at, last_active_at, generated_title, session_summary,
+//     git_root_dir, head_branch, head_commit, num_chat_messages, current_model_id}
+//   sessions/<url-encoded cwd>/<session-id>/chat_history.jsonl   lines
+//     {type:'user', content:[{type:'text',text}]} and {type:'assistant',
+//     content:'…'} (plus system and reasoning lines, skipped)
+//   sessions/<url-encoded cwd>/prompt_history.jsonl   {timestamp, session_id,
+//     prompt} per prompt: the turn count and the first prompt
+//   active_sessions.json   the sessions a running grok has open (an array;
+//     empty when none is running)
+// The directory name is grok's own encoding of the cwd and is never decoded:
+// summary.json names the cwd itself.
+import { join, resolve } from 'node:path'
+import { LAYOUT } from '../../accounts.mjs'
+import { readTail, jsonLines, line, isoOrNull, isoFromMs, safeList, safeStat, safeRead, PROMPT_MAX } from '../common.mjs'
+
+export const name = 'grok'
+export const label = 'Grok'
+export const ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+export function root(homes = {}) { return homes.grok ?? LAYOUT.grok.home() }
+
+function readJson(p) { try { return JSON.parse(safeRead(p) ?? '') } catch { return null } }
+
+function parseSummary(dir, st) {
+  const j = readJson(join(dir, 'summary.json'))
+  const id = j?.info?.id ?? j?.id
+  if (!j || typeof id !== 'string') return null
+  const gitRoot = typeof j.git_root_dir === 'string' ? resolve(j.git_root_dir) : null
+  return {
+    native_id: id,
+    cwd: typeof j.info?.cwd === 'string' ? j.info.cwd : null,
+    branch: typeof j.head_branch === 'string' ? j.head_branch : null,
+    title: line(j.generated_title ?? j.session_summary ?? '') || null,
+    started_at: isoOrNull(j.created_at) ?? isoFromMs(st.birthtimeMs),
+    updated_at: isoOrNull(j.last_active_at ?? j.updated_at) ?? isoFromMs(st.mtimeMs),
+    transcript_path: join(dir, 'chat_history.jsonl'),
+    size_bytes: safeStat(join(dir, 'chat_history.jsonl'))?.size ?? 0,
+    // session_kind: absent for an interactive session, "subagent" (listed only
+    // on request), "headless" (listed: a human asked for it)
+    native: { version: j.chat_format_version ?? null, model: j.current_model_id ?? null, git_root_dir: gitRoot, head_commit: j.head_commit ?? null, messages: Number.isFinite(j.num_chat_messages) ? j.num_chat_messages : null, kind: typeof j.session_kind === 'string' ? j.session_kind : 'session', subagent: j.session_kind === 'subagent' },
+  }
+}
+
+// prompt_history.jsonl for one cwd dir → { [session_id]: { count, first } }
+function promptIndex(f, prev) {
+  const st = safeStat(f)
+  if (!st) return { key: null, map: {} }
+  const key = `${st.mtimeMs}:${st.size}`
+  if (prev?.key === key) return prev
+  const map = {}
+  for (const j of jsonLines(safeRead(f))) {
+    if (typeof j.session_id !== 'string') continue
+    const cur = map[j.session_id] ?? (map[j.session_id] = { count: 0, first: null })
+    cur.count += 1
+    if (!cur.first && typeof j.prompt === 'string' && !j.prompt.startsWith('/')) cur.first = line(j.prompt, PROMPT_MAX)
+  }
+  return { key, map }
+}
+
+export function liveIds(home) {
+  const j = readJson(join(home, 'active_sessions.json'))
+  const out = new Set()
+  const push = (v) => { if (typeof v === 'string') out.add(v); else if (v && typeof v === 'object') { const id = v.id ?? v.session_id ?? v.info?.id; if (typeof id === 'string') out.add(id) } }
+  if (Array.isArray(j)) j.forEach(push)
+  else if (j && typeof j === 'object') { for (const [k, v] of Object.entries(j)) { if (Array.isArray(v)) v.forEach(push); else push(k) } }
+  return out
+}
+
+export function scan({ home, prev = {} }) {
+  const root = join(home, 'sessions')
+  const entries = {}
+  const prompts = {}
+  let scanned = 0; let parsed = 0
+  const before = prev.entries ?? {}
+  for (const cwdDir of safeList(root)) {
+    if (!cwdDir.isDirectory()) continue
+    const cdir = join(root, cwdDir.name)
+    const pi = promptIndex(join(cdir, 'prompt_history.jsonl'), prev.aux?.prompts?.[cwdDir.name])
+    prompts[cwdDir.name] = pi
+    for (const s of safeList(cdir)) {
+      if (!s.isDirectory()) continue
+      const dir = join(cdir, s.name)
+      const summary = join(dir, 'summary.json')
+      const st = safeStat(summary)
+      if (!st) continue
+      scanned += 1
+      const old = before[summary]
+      let entry = old && old.mtime === st.mtimeMs && old.size === st.size ? old : null
+      if (!entry) {
+        const record = parseSummary(dir, st)
+        parsed += 1
+        if (!record) continue
+        entry = { mtime: st.mtimeMs, size: st.size, record }
+      }
+      const p = pi.map[entry.record.native_id]
+      entry.record.turns = p?.count ?? null
+      if (!entry.record.title) entry.record.title = p?.first ?? null
+      entries[summary] = entry
+    }
+  }
+  const live = liveIds(home)
+  for (const e of Object.values(entries)) e.record.live = live.has(e.record.native_id)
+  return { entries, aux: { prompts }, scanned, parsed }
+}
+
+function textOf(content) {
+  if (typeof content === 'string') return content
+  if (Array.isArray(content)) return content.filter((c) => c?.type === 'text' && c.text).map((c) => c.text).join('\n')
+  return ''
+}
+
+export function messagesFromLines(lines, limit = 8) {
+  const out = []
+  for (const j of jsonLines(lines.join('\n'))) {
+    if (j.type !== 'user' && j.type !== 'assistant') continue
+    const text = textOf(j.content).trim()
+    if (!text || /^<[a-z_-]+>/i.test(text)) continue
+    out.push({ role: j.type, text: text.slice(0, 1500), ts: j.timestamp ?? null })
+  }
+  return out.slice(-limit)
+}
+
+export function messages(record, limit = 8) {
+  return messagesFromLines(readTail(record.transcript_path, 4 * 1024 * 1024).split('\n'), limit)
+}
+
+// `grok --resume <SESSION_ID>` (grok --help: "-r, --resume [<SESSION_ID_OR_TITLE>]
+// Resume a session by ID or title"; a UUID always means the id).
+export function resume(record) {
+  if (record.native?.subagent) return { supported: false, reason: 'a subagent session belongs to the session that spawned it' }
+  if (!ID_RE.test(record.native_id)) return { supported: false, reason: 'the session id is not one grok --resume accepts' }
+  return { supported: true, agent: 'grok', args: ['--resume', record.native_id] }
+}
+
+export const transcript = 'supported'

package/src/history/worktrees.mjs

@@ -0,0 +1,116 @@
+// worktrees — every checkout Leg can see, in one list: what git lists for each
+// repository it knows about, what its own sessions and cards cut, and what
+// the discovered conversations were working in. Read only: nothing here
+// prunes, removes or touches a worktree; src/worktree.mjs keeps that job, for
+// Leg's own worktrees only, unchanged.
+import { existsSync, statSync } from 'node:fs'
+import { execFileSync } from 'node:child_process'
+import { listSessions, isActive } from '../sessions.mjs'
+import { listCards } from '../store.mjs'
+import { parseWorktreeList } from '../worktree.mjs'
+import { listHistory } from './index.mjs'
+import { repoNameOf, canonOrNull } from './common.mjs'
+
+export const STALE_DAYS = 14
+export const DIRTY_LIMIT = 40
+export const REPO_LIMIT = 40
+
+const LEG_DIR_RE = /[\\/]\.(?:leg|baton)-worktrees[\\/]([^\\/]+)$/i
+
+function dirtyOf(path, timeoutMs = 5000) {
+  try {
+    const out = execFileSync('git', ['-c', 'core.fsmonitor=', '-c', 'core.hooksPath=', '-C', path, 'status', '--porcelain'], { windowsHide: true, encoding: 'utf8', timeout: timeoutMs, maxBuffer: 4 * 1024 * 1024, env: { ...process.env, MSYS_NO_PATHCONV: '1' }, stdio: ['ignore', 'pipe', 'ignore'] })
+    return out.split(/\r?\n/).filter(Boolean).length
+  } catch { return null }
+}
+
+// git's own list for one repository, stderr dropped: a repo that is not one
+// any more ("fatal: not a git repository") is an empty list, not a line on the
+// operator's terminal.
+function gitWorktrees(repo, timeoutMs = 5000) {
+  try {
+    const out = execFileSync('git', ['-c', 'core.fsmonitor=', '-c', 'core.hooksPath=', '-C', repo, 'worktree', 'list', '--porcelain'], { windowsHide: true, encoding: 'utf8', timeout: timeoutMs, maxBuffer: 4 * 1024 * 1024, env: { ...process.env, MSYS_NO_PATHCONV: '1' }, stdio: ['ignore', 'pipe', 'ignore'] })
+    return parseWorktreeList(out)
+  } catch { return [] }
+}
+
+const mtimeOf = (p) => { try { return statSync(p).mtimeMs } catch { return null } }
+const at = (iso) => (iso ? Date.parse(iso) || 0 : 0)
+
+// { worktrees: [...], repos, ts }. `dirty` runs git status on up to
+// `dirtyLimit` existing checkouts (null past the cap, so the board never waits
+// on two hundred of them). `records`/`sessions`/`cards` are for tests.
+export function listWorktrees({ dirty = true, dirtyLimit = DIRTY_LIMIT, repoLimit = REPO_LIMIT, repo = null, sessions = null, cards = null, records = null, homes = null, now = Date.now() } = {}) {
+  const sess = sessions ?? listSessions()
+  const crd = cards ?? listCards()
+  const recs = records ?? listHistory({ limit: 0, homes, includeSubagents: true }).records
+  const repos = new Map()
+  const addRepo = (p) => { const c = canonOrNull(p); if (c && !repos.has(c) && existsSync(p)) repos.set(c, p) }
+  for (const s of sess) addRepo(s.repo)
+  for (const c of crd) addRepo(c.repo)
+  for (const r of recs) addRepo(r.repo)
+  const only = repo ? canonOrNull(repo) : null
+  if (only) for (const k of [...repos.keys()]) if (k !== only) repos.delete(k)
+
+  const rows = new Map() // canon path → row
+  const row = (path, repoPath, extra = {}) => {
+    const key = canonOrNull(path)
+    if (!key) return null
+    if (only && canonOrNull(repoPath) !== only) return null
+    if (!rows.has(key)) rows.set(key, { path, repo: repoPath, repo_name: repoNameOf(repoPath), branch: null, head: null, exists: existsSync(path), main: false, listed_by_git: false, owner: { kind: 'external' }, conversations: { count: 0, latest: [], last_at: null }, dirty: null, stale: false, orphaned: false })
+    return Object.assign(rows.get(key), extra)
+  }
+  let repoCount = 0
+  for (const [, repoPath] of repos) {
+    if (repoCount >= repoLimit) break
+    repoCount += 1
+    gitWorktrees(repoPath).forEach((w, i) => row(w.path, repoPath, { branch: w.branch, head: w.head, listed_by_git: true, main: i === 0 && canonOrNull(w.path) === canonOrNull(repoPath) }))
+  }
+  // checkouts git no longer lists (deleted by hand, pruned) but a record still names
+  for (const s of sess) if (s.worktree?.path && s.repo) row(s.worktree.path, s.repo, { branch: rows.get(canonOrNull(s.worktree.path))?.branch ?? s.worktree.branch ?? null })
+  for (const c of crd) if (c.worktree && c.repo) row(c.worktree, c.repo)
+  for (const r of recs) if (r.worktree?.path && r.repo) row(r.worktree.path, r.repo, { branch: rows.get(canonOrNull(r.worktree.path))?.branch ?? r.worktree.branch ?? null })
+
+  // owners: a session's own worktree, a card's, or the main checkout
+  const byCard = new Map(crd.map((c) => [c.card_id, c]))
+  for (const s of sess) {
+    if (!s.worktree?.path) continue
+    const r = rows.get(canonOrNull(s.worktree.path))
+    if (!r) continue
+    const prior = r.owner.kind === 'session' ? sess.find((x) => x.session_id === r.owner.id) : null
+    // a live session outranks a finished one on the same path
+    if (!prior || (!isActive(prior) && isActive(s))) r.owner = { kind: 'session', id: s.session_id, agent: s.agent, status: s.status, live: isActive(s), updated_at: s.updated_at ?? null }
+  }
+  for (const r of rows.values()) {
+    if (r.owner.kind !== 'external') continue
+    const m = LEG_DIR_RE.exec(r.path)
+    if (m && byCard.has(m[1])) { const c = byCard.get(m[1]); r.owner = { kind: 'card', id: c.card_id, status: c.status, live: ['running', 'handing_off'].includes(c.status), updated_at: c.updated_at ?? null }; continue }
+    if (r.main) r.owner = { kind: 'checkout' }
+    else if (m) r.orphaned = true
+  }
+  // which conversations point here
+  const convs = new Map()
+  for (const rec of recs) {
+    const key = canonOrNull(rec.worktree?.path) ?? (rec.repo && !rec.worktree ? canonOrNull(rec.repo) : null)
+    if (!key || !rows.has(key)) continue
+    if (!convs.has(key)) convs.set(key, [])
+    convs.get(key).push(rec)
+  }
+  for (const [key, list] of convs) {
+    list.sort((a, b) => at(b.updated_at) - at(a.updated_at))
+    rows.get(key).conversations = { count: list.length, last_at: list[0]?.updated_at ?? null, latest: list.slice(0, 3).map((r) => ({ id: r.id, provider: r.provider, managed: r.managed, live: r.live, title: r.title, updated_at: r.updated_at })) }
+  }
+  // dirty and stale
+  let checked = 0
+  for (const r of rows.values()) {
+    if (r.exists && dirty && checked < dirtyLimit) { r.dirty = dirtyOf(r.path); checked += 1 }
+    const liveOwner = Boolean(r.owner.live)
+    const last = Math.max(at(r.conversations.last_at), at(r.owner.updated_at), r.exists ? (mtimeOf(r.path) ?? 0) : 0)
+    r.last_activity_at = last ? new Date(last).toISOString() : null
+    r.stale = r.exists && !r.main && !liveOwner && (!last || now - last > STALE_DAYS * 86400000)
+  }
+  const out = [...rows.values()].sort((a, b) => String(a.repo).localeCompare(String(b.repo)) || (a.main ? -1 : b.main ? 1 : 0) || a.path.localeCompare(b.path))
+  return { worktrees: out, repos: repos.size, dirty_checked: checked, ts: new Date(now).toISOString() }
+}
+
+export function underLegWorktrees(path) { return LEG_DIR_RE.test(String(path ?? '')) }