@threadcrumbs/common 0.0.0-stage → 0.1.1

package/telemetry/cursor.mjs

@@ -0,0 +1,276 @@
+import fsp from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { decodeProjectDir } from '../lib/cursor-folder.mjs'
+import { exists, listDirs, listFiles } from '../lib/fsutil.mjs'
+import { jsonlFollower } from '../lib/jsonl-follower.mjs'
+import {
+  DETAIL_LIMITS,
+  RECENT_MS,
+  activityDetail,
+  clip,
+  clipBlock,
+  emptyActivity,
+  keepNewest,
+  nextPlan,
+  planItems,
+  planSummary,
+  relativePath,
+  startCall,
+  text,
+  titleFromPrompt,
+  toolFile,
+  toolInput,
+  toolTarget,
+} from '../lib/telemetry-fields.mjs'
+
+const ACTIVE_WINDOW_MS = 30 * 60 * 1000
+const SUBAGENT_WINDOW_MS = 10 * 60 * 1000
+const TRANSCRIPTS = 'agent-transcripts'
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+const FLAT_TRANSCRIPT = /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i
+const USER_ABORT = /user aborted/i
+
+function rawText(record) {
+  const parts = record?.message?.content
+  return Array.isArray(parts) ? parts.map((p) => (typeof p === 'string' ? p : text(p?.text))).join('\n') : text(parts)
+}
+
+function userText(record) {
+  const raw = rawText(record)
+  const query = /<user_query>\s*([\s\S]*?)\s*<\/user_query>/.exec(raw)
+  return (query ? query[1] : raw.replace(/<[a-z_]+>[\s\S]*?<\/[a-z_]+>/gi, ' ')).trim()
+}
+
+function stamp(record) {
+  const m = /<timestamp>(.*?)<\/timestamp>/.exec(rawText(record))
+  const t = m ? Date.parse(m[1].replace(/\s*\(UTC[^)]*\)\s*$/, '')) : NaN
+  return Number.isNaN(t) ? 0 : t
+}
+
+function emptyTranscript() {
+  return {
+    firstPrompt: '',
+    startedAt: 0,
+    prompts: 0,
+    marked: false,
+    closed: false,
+    failed: false,
+    modelsTurn: false,
+    tool: null,
+    plan: null,
+    activity: emptyActivity(),
+    promptList: [],
+    errors: [],
+  }
+}
+
+function applyRecord(state, record) {
+  if (record.type === 'turn_ended') {
+    state.marked = true
+    state.closed = true
+    state.failed = record.status !== 'success' && !USER_ABORT.test(text(record.error))
+    state.modelsTurn = false
+    state.tool = null
+    if (state.failed) {
+      keepNewest(state.errors, { at: 0, message: clip(text(record.error) || 'The turn ended in an error', DETAIL_LIMITS.errorText) }, DETAIL_LIMITS.errors)
+    }
+    return
+  }
+  state.closed = false
+  if (record.role === 'user') {
+    const prompt = userText(record)
+    if (prompt) {
+      state.prompts++
+      state.firstPrompt ||= prompt
+      state.startedAt ||= stamp(record)
+      keepNewest(state.promptList, { at: stamp(record), text: clipBlock(prompt, DETAIL_LIMITS.promptText) }, DETAIL_LIMITS.prompts)
+    }
+    state.modelsTurn = true
+    state.tool = null
+    return
+  }
+  if (record.role !== 'assistant') return
+  const content = Array.isArray(record.message?.content) ? record.message.content : []
+  const calls = content.filter((c) => c?.type === 'tool_use')
+  for (const call of calls) {
+    state.plan = nextPlan(state.plan, text(call.name), call.input)
+    startCall(state.activity, { name: text(call.name), target: toolTarget(call.input, '', Infinity), input: toolInput(call.input), ...toolFile(call.input), startedAt: 0, running: false })
+  }
+  state.modelsTurn = calls.length > 0
+  state.tool = calls.length ? { name: text(calls.at(-1).name), startedAt: 0 } : null
+}
+
+export function cursor({
+  projectsDir = process.env.THREADCRUMBS_CURSOR_PROJECTS_DIR || path.join(os.homedir(), '.cursor', 'projects'),
+  now = Date.now,
+} = {}) {
+  const transcripts = jsonlFollower({ empty: emptyTranscript, apply: applyRecord })
+  const subagentFiles = jsonlFollower({ empty: emptyTranscript, apply: applyRecord })
+  let subagentsSweptAt = 0
+  let known = new Map()
+
+  async function follow(file, stat, reader = transcripts) {
+    const state = await reader.read(file, stat)
+    const seenAt = Math.floor(stat.mtimeMs)
+    if (state.tool && !state.tool.startedAt) state.tool.startedAt = seenAt
+    for (const call of state.activity.calls) if (!call.startedAt) call.startedAt = seenAt
+    return state
+  }
+
+  const isOpen = (state, fresh) => fresh && (state.marked ? !state.closed : state.modelsTurn)
+
+  async function findTranscripts() {
+    const cutoff = now() - RECENT_MS
+    const out = []
+    const add = async (id, file, projectDir, sessionDir) => {
+      const stat = await fsp.stat(file).catch(() => null)
+      if (stat && stat.size && stat.mtimeMs >= cutoff) out.push({ id, file, stat, projectDir, sessionDir })
+    }
+    for (const projectDir of await listDirs(projectsDir)) {
+      const root = path.join(projectDir, TRANSCRIPTS)
+      for (const sessionDir of await listDirs(root)) {
+        const id = path.basename(sessionDir)
+        if (!UUID.test(id)) continue
+        for (const file of await listFiles(sessionDir, (n) => n.endsWith('.jsonl'))) await add(id, file, projectDir, sessionDir)
+      }
+      for (const file of await listFiles(root, (n) => FLAT_TRANSCRIPT.test(n))) {
+        await add(FLAT_TRANSCRIPT.exec(path.basename(file))[1], file, projectDir, '')
+      }
+    }
+    return out
+  }
+
+  async function runningSubagents(sessionDir) {
+    if (!sessionDir) return 0
+    let count = 0
+    for (const file of await listFiles(path.join(sessionDir, 'subagents'), (n) => n.endsWith('.jsonl'))) {
+      const stat = await fsp.stat(file).catch(() => null)
+      if (!stat || now() - stat.mtimeMs > SUBAGENT_WINDOW_MS) continue
+      const state = await follow(file, stat, subagentFiles).catch(() => null)
+      if (state && isOpen(state, true)) count++
+    }
+    return count
+  }
+
+  async function subagentList(sessionDir) {
+    if (!sessionDir) return []
+    const list = []
+    for (const file of await listFiles(path.join(sessionDir, 'subagents'), (n) => n.endsWith('.jsonl'))) {
+      const stat = await fsp.stat(file).catch(() => null)
+      if (!stat) continue
+      const state = await follow(file, stat, subagentFiles).catch(() => null)
+      if (!state) continue
+      const open = isOpen(state, now() - stat.mtimeMs <= SUBAGENT_WINDOW_MS)
+      const name = path.basename(file, '.jsonl')
+      list.push({
+        id: name,
+        name: titleFromPrompt(state.firstPrompt) || name,
+        type: '',
+        status: open ? 'working' : state.failed ? 'error' : 'done',
+        model: '',
+        tokens: null,
+        tool: open && state.tool ? { ...state.tool } : null,
+        startedAt: state.startedAt || Math.floor(stat.birthtimeMs) || Math.floor(stat.mtimeMs),
+        lastActivityAt: Math.floor(stat.mtimeMs),
+      })
+    }
+    return list.sort((a, b) => a.startedAt - b.startedAt).slice(-DETAIL_LIMITS.subagents)
+  }
+
+  async function sessionDetail(key) {
+    const id = String(key).replace(/^cursor:/, '')
+    const entry = known.get(id)
+    const stat = entry ? await fsp.stat(entry.file).catch(() => null) : null
+    if (!stat) return null
+    const state = await follow(entry.file, stat)
+    const open = isOpen(state, now() - stat.mtimeMs < ACTIVE_WINDOW_MS)
+    const { activity, tools } = activityDetail(state.activity)
+    for (const call of activity) {
+      call.target = clip(relativePath(call.target, entry.projectPath))
+      if (call.path) call.path = relativePath(call.path, entry.projectPath)
+    }
+    if (open && state.tool && activity.length) activity.at(-1).running = true
+    return {
+      id: `cursor:${id}`,
+      sessionId: id,
+      source: entry.file,
+      models: null,
+      history: null,
+      compactions: null,
+      contextParts: null,
+      activity,
+      tools,
+      plan: planItems(state.plan),
+      subagents: await subagentList(entry.sessionDir),
+      files: null,
+      prompts: state.promptList.map((p) => ({ ...p })),
+      errors: state.errors.map((e) => ({ ...e })),
+    }
+  }
+
+  async function scanSessions() {
+    const sessions = []
+    const found = new Map()
+    for (const entry of await findTranscripts()) {
+      let state
+      try {
+        state = await follow(entry.file, entry.stat)
+      } catch {
+        continue
+      }
+      const fresh = now() - entry.stat.mtimeMs < ACTIVE_WINDOW_MS
+      const open = isOpen(state, fresh)
+      const subagents = await runningSubagents(entry.sessionDir)
+      const projectPath = await decodeProjectDir(path.basename(entry.projectDir))
+      found.set(entry.id, { file: entry.file, sessionDir: entry.sessionDir, projectPath })
+      let status
+      if (subagents) status = 'delegating'
+      else if (open) status = 'working'
+      else if (state.failed) status = 'error'
+      else status = fresh ? 'done' : 'idle'
+      sessions.push({
+        id: `cursor:${entry.id}`,
+        harness: 'cursor',
+        title: (state.firstPrompt ? titleFromPrompt(state.firstPrompt) : '') || 'Untitled session',
+        project: path.basename(projectPath) || 'unknown',
+        projectPath,
+        worktree: '',
+        cwd: projectPath,
+        gitBranch: '',
+        model: '',
+        effort: '',
+        status,
+        live: open,
+        startedAt: state.startedAt || Math.floor(entry.stat.birthtimeMs) || Math.floor(entry.stat.mtimeMs),
+        lastActivityAt: Math.floor(entry.stat.mtimeMs),
+        tool: open && state.tool ? { ...state.tool } : null,
+        tokens: null,
+        context: null,
+        costUsd: null,
+        lines: null,
+        plan: planSummary(state.plan),
+        subagents,
+        prompts: state.prompts,
+      })
+    }
+    transcripts.sweep()
+    known = found
+    if (now() - subagentsSweptAt >= SUBAGENT_WINDOW_MS) {
+      subagentsSweptAt = now()
+      subagentFiles.sweep()
+    }
+    return sessions
+  }
+
+  return {
+    id: 'cursor',
+    name: 'Cursor',
+    detect: () => exists(projectsDir),
+    watchRoots: () => [projectsDir],
+    scanSessions,
+    sessionDetail,
+  }
+}
+
+export default cursor()

package/telemetry/hermes.mjs

@@ -0,0 +1,404 @@
+import fsp from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { exists, listDirs } from '../lib/fsutil.mjs'
+import { resolveHermesHome } from '../lib/hermes-home.mjs'
+import { columnsOf, tablesOf, withReadOnly } from '../lib/sqlite.mjs'
+import {
+  DETAIL_LIMITS,
+  RECENT_MS,
+  activityDetail,
+  clip,
+  clipBlock,
+  emptyActivity,
+  endCall,
+  keepNewest,
+  number,
+  planItems,
+  planSummary,
+  settleCalls,
+  startCall,
+  text,
+  titleFromPrompt,
+  toolFile,
+  toolInput,
+  toolTarget,
+} from '../lib/telemetry-fields.mjs'
+
+const ACTIVE_WINDOW_MS = 30 * 60 * 1000
+const FORK_MARKERS = ['_branched_from', '_delegate_from', '_reset_from']
+const DELEGATE_TOOLS = new Set(['delegate_task'])
+const TODO_TOOLS = ['todo_list', 'todo']
+const ASKING = /^waiting for user (approval|clarify)/i
+const TOOL_LABEL = /^(?:executing tool|sequential tool running \([^)]*\)): (.+)$/i
+const SESSION_COLUMNS = [
+  'id', 'title', 'model', 'source', 'cwd', 'git_branch', 'git_repo_root', 'started_at', 'ended_at',
+  'last_activity_at', 'last_activity_description', 'parent_session_id', 'end_reason', 'model_config', 'hidden',
+  'input_tokens', 'output_tokens', 'cache_read_tokens', 'cache_write_tokens', 'estimated_cost_usd',
+  'actual_cost_usd', 'billing_base_url', 'archived', 'last_read_at',
+]
+
+const seconds = (v) => Math.round(number(v) * 1000)
+
+function parseConfig(raw) {
+  try {
+    const config = JSON.parse(raw || '{}')
+    return config && typeof config === 'object' ? config : {}
+  } catch {
+    return {}
+  }
+}
+
+const unquote = (key) => {
+  if (/^'.*'$/.test(key)) return key.slice(1, -1).replace(/''/g, "'")
+  if (/^".*"$/.test(key)) {
+    try {
+      return JSON.parse(key)
+    } catch {
+      return key.slice(1, -1)
+    }
+  }
+  return key
+}
+
+export function parseContextLengths(source) {
+  const lengths = new Map()
+  let inSection = false
+  for (const line of text(source).split(/\r?\n/)) {
+    if (/^\S/.test(line)) {
+      inSection = /^context_lengths:\s*$/.test(line)
+      continue
+    }
+    const entry = inSection && /^\s+(.+?):\s+(\d+)\s*$/.exec(line)
+    if (entry) lengths.set(unquote(entry[1]), Number(entry[2]))
+  }
+  return lengths
+}
+
+function contextLimit(lengths, model, baseUrl) {
+  if (!model) return 0
+  const exact = lengths.get(`${model}@${text(baseUrl).replace(/\/+$/, '')}`)
+  if (exact) return exact
+  for (const [key, limit] of lengths) if (key.startsWith(`${model}@`)) return limit
+  return 0
+}
+
+export function hermes({ home = resolveHermesHome(), now = Date.now } = {}) {
+  const mainDb = path.join(home, 'state.db')
+  const contextCaches = new Map()
+
+  async function storeFiles() {
+    const files = [{ profile: 'main', dir: home, file: mainDb }]
+    for (const dir of await listDirs(path.join(home, 'profiles'))) {
+      const file = path.join(dir, 'state.db')
+      if (await exists(file)) files.push({ profile: path.basename(dir), dir, file })
+    }
+    return files
+  }
+
+  async function contextLengths(dir) {
+    const file = path.join(dir, 'context_length_cache.yaml')
+    const stat = await fsp.stat(file).catch(() => null)
+    if (!stat) return new Map()
+    const hit = contextCaches.get(file)
+    if (hit && hit.mtime === stat.mtimeMs) return hit.lengths
+    const lengths = parseContextLengths(await fsp.readFile(file, 'utf8').catch(() => ''))
+    contextCaches.set(file, { mtime: stat.mtimeMs, lengths })
+    return lengths
+  }
+
+  async function scanSessions() {
+    const sessions = []
+    for (const store of await storeFiles()) {
+      const lengths = await contextLengths(store.dir)
+      const found = await withReadOnly(store.file, (db) => sessionsFrom(db, store.profile, lengths, home, now()), [])
+      sessions.push(...found)
+    }
+    return sessions
+  }
+
+  async function sessionDetail(key) {
+    const match = /^hermes:([^:]+):(.+)$/.exec(String(key))
+    if (!match) return null
+    const [, profile, rootId] = match
+    const store = (await storeFiles()).find((s) => s.profile === profile)
+    if (!store) return null
+    const detail = await withReadOnly(store.file, (db) => detailFrom(db, rootId, now()), null)
+    return detail && { id: `hermes:${profile}:${rootId}`, sessionId: rootId, source: store.file, ...detail }
+  }
+
+  return {
+    id: 'hermes',
+    name: 'Hermes',
+    detect: () => exists(mainDb),
+    watchRoots: () => [home],
+    scanSessions,
+    sessionDetail,
+  }
+}
+
+function lineage(db, at) {
+  const tables = tablesOf(db)
+  if (!tables.has('sessions') || !tables.has('messages')) return null
+  const cols = columnsOf(db, 'sessions')
+  if (!['id', 'started_at'].every((c) => cols.has(c))) return null
+  const rows = db.prepare(`SELECT ${SESSION_COLUMNS.map((c) => (cols.has(c) ? c : `NULL AS ${c}`)).join(', ')} FROM sessions`).all()
+  for (const row of rows) row.config = parseConfig(row.model_config)
+  const leases = tables.has('session_turn_leases')
+    ? new Set(db.prepare('SELECT conversation_id FROM session_turn_leases WHERE expires_at > ?').all(at / 1000).map((r) => r.conversation_id))
+    : null
+  const messages = columnsOf(db, 'messages')
+  if (!['id', 'session_id', 'role', 'content'].every((c) => messages.has(c))) return null
+  const visible = messages.has('active') ? (messages.has('compacted') ? 'AND (active = 1 OR compacted = 1)' : 'AND active = 1') : ''
+
+  const byId = new Map(rows.map((r) => [r.id, r]))
+  const fork = (row) => FORK_MARKERS.find((key) => row.config[key] != null) || ''
+  const continues = (row) => {
+    const parent = row.parent_session_id ? byId.get(row.parent_session_id) : null
+    return parent && parent.end_reason === 'compression' && !fork(row) ? parent : null
+  }
+  const continued = new Set(rows.map(continues).filter(Boolean).map((p) => p.id))
+  const isErrand = (row) => row.source === 'subagent' || fork(row) === '_delegate_from'
+  const lastAt = (row) => seconds(row.last_activity_at || row.ended_at || row.started_at)
+  const chainOf = (tip) => {
+    const chain = [tip]
+    for (let parent = continues(tip); parent && chain.length <= rows.length; parent = continues(parent)) chain.push(parent)
+    return chain
+  }
+  const turnOpen = (row, root) =>
+    leases ? leases.has(root.id) : Boolean(text(row.last_activity_description)) && at - lastAt(row) < ACTIVE_WINDOW_MS
+  return { rows, continued, isErrand, lastAt, chainOf, turnOpen, messages, visible }
+}
+
+function sessionsFrom(db, profile, lengths, home, at) {
+  const found = lineage(db, at)
+  if (!found) return []
+  const { rows, continued, isErrand, lastAt, chainOf, turnOpen, messages, visible } = found
+
+  const out = []
+  for (const tip of rows) {
+    if (continued.has(tip.id) || isErrand(tip) || number(tip.hidden) || number(tip.archived) || tip.source === 'cron') continue
+    const chain = chainOf(tip)
+    const root = chain[chain.length - 1]
+    const open = turnOpen(tip, root)
+    if (!open && at - lastAt(tip) > RECENT_MS) continue
+    const ids = chain.map((r) => r.id)
+    const errands = rows.filter((r) => isErrand(r) && ids.includes(r.parent_session_id) && turnOpen(r, chainOf(r).at(-1))).length
+    out.push(toSession({ db, profile, tip, root, chain, ids, open, errands, lengths, home, messages, visible, at, lastAt: lastAt(tip) }))
+  }
+  return out
+}
+
+function parseJson(raw, fallback) {
+  try {
+    return JSON.parse(raw)
+  } catch {
+    return fallback
+  }
+}
+
+const FAILED_END = /error|fail/i
+
+function detailFrom(db, rootId, at) {
+  const found = lineage(db, at)
+  if (!found) return null
+  const { rows, continued, isErrand, lastAt, chainOf, turnOpen, messages, visible } = found
+  const tip = rows.find((r) => !continued.has(r.id) && !isErrand(r) && chainOf(r).at(-1).id === rootId)
+  if (!tip) return null
+  const chain = chainOf(tip)
+  const ids = chain.map((r) => r.id)
+  const placeholders = ids.map(() => '?').join(', ')
+  const open = turnOpen(tip, chain.at(-1))
+  const cwd = text(tip.cwd)
+
+  const activity = emptyActivity()
+  const prompts = []
+  const pick = (column, fallback = 'NULL') => (messages.has(column) ? column : `${fallback} AS ${column}`)
+  const order = messages.has('timestamp') ? 'timestamp, id' : 'id'
+  const records = db
+    .prepare(
+      `SELECT id, role, CASE WHEN role = 'user' THEN content END AS content, ${pick('tool_calls')}, ${pick('tool_call_id')}, ${pick('timestamp', '0')}
+       FROM messages WHERE session_id IN (${placeholders}) ${visible} ORDER BY ${order}`,
+    )
+    .all(...ids)
+  for (const record of records) {
+    const time = seconds(record.timestamp)
+    if (record.role === 'user') {
+      settleCalls(activity)
+      const prompt = text(record.content).trim()
+      if (prompt) keepNewest(prompts, { at: time, text: clipBlock(prompt, DETAIL_LIMITS.promptText) }, DETAIL_LIMITS.prompts)
+    } else if (record.role === 'assistant' && record.tool_calls) {
+      for (const call of parseJson(record.tool_calls, [])) {
+        if (!call?.id) continue
+        const args = typeof call.function?.arguments === 'string' ? parseJson(call.function.arguments, null) : call.function?.arguments
+        startCall(activity, { id: text(call.id), name: text(call.function?.name), target: toolTarget(args, cwd), input: toolInput(args), ...toolFile(args, cwd), startedAt: time })
+      }
+    } else if (record.role === 'tool' && record.tool_call_id) {
+      endCall(activity, text(record.tool_call_id), time, null)
+    }
+  }
+  if (!open) settleCalls(activity)
+
+  const subagents = rows
+    .filter((r) => isErrand(r) && ids.includes(r.parent_session_id))
+    .map((r) => {
+      const working = turnOpen(r, chainOf(r).at(-1))
+      const label = TOOL_LABEL.exec(text(r.last_activity_description))
+      const tokens = ['input_tokens', 'output_tokens', 'cache_read_tokens', 'cache_write_tokens'].map((c) => (r[c] == null ? null : number(r[c])))
+      return {
+        id: r.id,
+        name: text(r.title) || 'Subagent',
+        type: text(r.source) === 'subagent' ? '' : 'delegate',
+        status: working ? 'working' : FAILED_END.test(text(r.end_reason)) ? 'error' : r.ended_at != null ? 'done' : 'idle',
+        model: text(r.model),
+        tokens: tokens.some((t) => t != null) ? { input: tokens[0] || 0, output: tokens[1] || 0, cacheRead: tokens[2] || 0, cacheWrite: tokens[3] || 0 } : null,
+        tool: working && label ? { name: label[1].trim(), startedAt: seconds(r.last_activity_at) } : null,
+        startedAt: seconds(r.started_at),
+        lastActivityAt: lastAt(r),
+      }
+    })
+    .sort((a, b) => a.startedAt - b.startedAt)
+    .slice(-DETAIL_LIMITS.subagents)
+
+  const models = new Map()
+  for (const row of chain) {
+    const model = text(row.model)
+    if (!model) continue
+    const entry = models.get(model) || { model, tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, costUsd: null }
+    entry.tokens.input += number(row.input_tokens)
+    entry.tokens.output += number(row.output_tokens)
+    entry.tokens.cacheRead += number(row.cache_read_tokens)
+    entry.tokens.cacheWrite += number(row.cache_write_tokens)
+    const cost = row.actual_cost_usd ?? row.estimated_cost_usd
+    if (cost != null) entry.costUsd = (entry.costUsd || 0) + number(cost)
+    models.set(model, entry)
+  }
+
+  const errors = chain
+    .filter((r) => FAILED_END.test(text(r.end_reason)))
+    .map((r) => ({ at: seconds(r.ended_at), message: `The session ended: ${text(r.end_reason)}` }))
+    .reverse()
+
+  return {
+    models: [...models.values()],
+    history: null,
+    compactions: null,
+    contextParts: null,
+    ...activityDetail(activity),
+    plan: planItems(latestPlan(db, ids, messages)),
+    subagents,
+    files: null,
+    prompts,
+    errors,
+  }
+}
+
+function openCalls(db, sessionId, messages, visible) {
+  if (!['tool_calls', 'tool_call_id', 'timestamp'].every((c) => messages.has(c))) return []
+  const last = db
+    .prepare(`SELECT id, tool_calls, timestamp FROM messages WHERE session_id = ? AND role = 'assistant' ${visible} ORDER BY id DESC LIMIT 1`)
+    .get(sessionId)
+  if (!last?.tool_calls) return []
+  let calls
+  try {
+    calls = JSON.parse(last.tool_calls)
+  } catch {
+    return []
+  }
+  const answered = new Set(
+    db.prepare(`SELECT tool_call_id FROM messages WHERE session_id = ? AND role = 'tool' AND id > ?`).all(sessionId, last.id).map((r) => r.tool_call_id),
+  )
+  return (Array.isArray(calls) ? calls : [])
+    .filter((c) => c?.id && !answered.has(c.id))
+    .map((c) => ({ name: text(c.function?.name), startedAt: seconds(last.timestamp) }))
+}
+
+function latestPlan(db, ids, messages) {
+  if (!messages.has('tool_name') || !messages.has('timestamp')) return null
+  const row = db
+    .prepare(
+      `SELECT content FROM messages WHERE session_id IN (${ids.map(() => '?').join(', ')}) AND role = 'tool' AND tool_name IN (${TODO_TOOLS.map(() => '?').join(', ')}) ORDER BY timestamp DESC, id DESC LIMIT 1`,
+    )
+    .get(...ids, ...TODO_TOOLS)
+  try {
+    const todos = JSON.parse(row?.content || '{}').todos
+    return Array.isArray(todos) ? todos.map((t) => ({ content: text(t?.content), status: text(t?.status) || 'pending' })) : null
+  } catch {
+    return null
+  }
+}
+
+function sum(chain, column) {
+  let total = 0
+  let known = false
+  for (const row of chain) {
+    if (row[column] == null) continue
+    total += number(row[column])
+    known = true
+  }
+  return known ? total : null
+}
+
+function toSession({ db, profile, tip, root, chain, ids, open, errands, lengths, home, messages, visible, at, lastAt }) {
+  const description = text(tip.last_activity_description)
+  const placeholders = ids.map(() => '?').join(', ')
+  const calls = open ? openCalls(db, tip.id, messages, visible) : []
+  const working = calls.filter((c) => !DELEGATE_TOOLS.has(c.name))
+  let status
+  if (open) {
+    if (ASKING.test(description)) status = 'asking'
+    else status = !working.length && (calls.length || errands) ? 'delegating' : 'working'
+  } else if (errands) status = 'delegating'
+  else if (tip.last_read_at != null) status = seconds(tip.last_activity_at || tip.started_at) > seconds(tip.last_read_at) ? 'done' : 'idle'
+  else status = tip.ended_at == null && at - lastAt < ACTIVE_WINDOW_MS ? 'done' : 'idle'
+
+  let tool = null
+  if (status === 'working' || status === 'delegating') {
+    const latest = (working.length ? working : calls).at(-1)
+    const label = TOOL_LABEL.exec(description)
+    if (latest) tool = latest
+    else if (label) tool = { name: label[1].trim(), startedAt: seconds(tip.last_activity_at) }
+  }
+
+  const where = text(tip.git_repo_root) || text(tip.cwd)
+  const userHome = os.homedir()
+  const atHome = !where || where === userHome || where === home || where === path.join(userHome, '.hermes')
+  const anchor = tip.config._usage_anchor
+  const used = anchor ? number(anchor.prompt_tokens) + number(anchor.completion_tokens) : 0
+  const reasoning = tip.config.reasoning_config
+  const tokens = ['input_tokens', 'output_tokens', 'cache_read_tokens', 'cache_write_tokens'].map((c) => sum(chain, c))
+  const costs = chain.map((r) => r.actual_cost_usd ?? r.estimated_cost_usd)
+  const firstPrompt = db
+    .prepare(`SELECT content FROM messages WHERE session_id = ? AND role = 'user' ORDER BY id ASC LIMIT 1`)
+    .get(root.id)?.content
+  const prompts = db.prepare(`SELECT COUNT(*) AS n FROM messages WHERE session_id IN (${placeholders}) AND role = 'user' ${visible}`).get(...ids)
+
+  return {
+    id: `hermes:${profile}:${root.id}`,
+    harness: 'hermes',
+    title: text(tip.title) || text(root.title) || titleFromPrompt(text(firstPrompt)) || 'Untitled session',
+    project: atHome ? 'Hermes' : path.basename(where.replace(/\\/g, '/')),
+    projectPath: atHome ? userHome : where,
+    worktree: '',
+    cwd: text(tip.cwd),
+    gitBranch: text(tip.git_branch),
+    model: text(tip.model),
+    effort: reasoning && reasoning.enabled !== false ? text(reasoning.effort) : '',
+    status,
+    live: open,
+    startedAt: seconds(root.started_at),
+    lastActivityAt: lastAt,
+    tool,
+    tokens: tokens.some((t) => t != null)
+      ? { input: tokens[0] || 0, output: tokens[1] || 0, cacheRead: tokens[2] || 0, cacheWrite: tokens[3] || 0 }
+      : null,
+    context: used ? { used, limit: contextLimit(lengths, text(tip.model), tip.billing_base_url) } : null,
+    costUsd: costs.some((c) => c != null) ? costs.reduce((total, c) => total + number(c), 0) : null,
+    lines: null,
+    plan: planSummary(latestPlan(db, ids, messages)),
+    subagents: errands,
+    prompts: number(prompts?.n),
+  }
+}
+
+export default hermes()

package/telemetry/index.mjs

@@ -0,0 +1,9 @@
+import antigravity from './antigravity.mjs'
+import claudeCode from './claude-code.mjs'
+import codex from './codex.mjs'
+import cursor from './cursor.mjs'
+import hermes from './hermes.mjs'
+import kilocode from './kilocode.mjs'
+import opencode from './opencode.mjs'
+
+export const TELEMETRY = [claudeCode, codex, cursor, antigravity, hermes, kilocode, opencode]