@threadcrumbs/common 0.0.0-stage → 0.1.1

package/package.json

@@ -1,6 +1,42 @@
 {
   "name": "@threadcrumbs/common",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "type": "module",
+  "description": "Code the Threadcrumbs apps share, starting with the readers for each coding-agent harness.",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "author": "Threadcrumbs LLC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/threadcrumbs/common.git"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "packageManager": "pnpm@11.9.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    "./harnesses": "./harnesses/index.mjs",
+    "./harnesses/*": "./harnesses/*.mjs",
+    "./telemetry": "./telemetry/index.mjs",
+    "./telemetry/*": "./telemetry/*.mjs",
+    "./launch": "./launch/index.mjs",
+    "./license": "./license/index.mjs",
+    "./license/store": "./license/store.mjs",
+    "./orgs": "./orgs/index.mjs",
+    "./lib/*": "./lib/*.mjs"
+  },
+  "files": [
+    "NOTICES.md",
+    "harnesses/",
+    "launch/",
+    "license/",
+    "lib/",
+    "orgs/",
+    "telemetry/"
+  ],
+  "scripts": {
+    "test": "node --test \"test/**/*.test.mjs\""
+  }
+}

package/telemetry/README.md

@@ -0,0 +1,148 @@
+# Harness telemetry readers
+
+A **harness** is whatever runs the agent sessions: Claude Code, Codex, OpenCode, and so on. Each
+file here reads one harness's own session files and reports live telemetry for each session:
+what it's doing now, its context, tokens, spend, and plan. Threadgauge shows them.
+
+These are the telemetry half of each harness. The other half, finding every thread and opening
+it, is in [`../harnesses/`](../harnesses/README.md), which Threadnauts uses. They're imported
+separately (`@threadcrumbs/common/telemetry` and `@threadcrumbs/common/harnesses`), so an app
+that only needs one half never loads the other.
+
+## The shape of it
+
+```js
+export default {
+  id: 'my-harness',
+  name: 'My Harness',
+  detect,
+  watchRoots,
+  scanSessions,
+  sessionDetail,
+}
+```
+
+| Member | What it does |
+| --- | --- |
+| `id` | Stable and kebab-case. It's part of every session id, so it must never change |
+| `name` | What a person sees |
+| `detect()` | `Promise<boolean>`: is this harness on this machine at all? It runs on every scan, so keep it cheap |
+| `watchRoots()` | The folders to watch recursively. A change anywhere under them triggers a scan |
+| `scanSessions()` | `Promise<Session[]>`: the sessions worth showing now. Cache against file size and mtime, because it runs often |
+| `sessionDetail(id, options)` | Optional. `Promise<Detail \| null>`: one session's details, for Threadgauge's details panel. `null` for an id the last scan didn't list. It runs about once a second while that panel is open, so build it from state the scan already keeps, or one read-only query. Claude Code also takes `{ subagent }`, a subagent's id from `subagents`, and returns that subagent's own Detail, with `agentId` set and `subagents: null` |
+| `readSession(id, options)` | Optional, Claude Code only so far. `Promise<{ session, detail } \| null>`: one session read on demand, even one older than the last day that `scanSessions` leaves out, so Threadgauge Pro can open an older thread. Takes `{ subagent }` like `sessionDetail`. It keeps the last few files it read, so asking again reads only what was added |
+
+Throwing from `scanSessions` is survivable. Threadgauge's monitor reports the error under the
+harness's name and carries on with the other harnesses.
+
+Register a reader by adding it to `TELEMETRY` in `index.mjs`. Use the same `id` as that harness's
+adapter in `../harnesses/`, so a session has the same id in both apps. Add the harness to
+`test/shared-ids.test.mjs` too, which fails until both readers are compared on one fake install.
+
+## The `Session`
+
+| Field | Type | What it means |
+| --- | --- | --- |
+| `id` | string | `<harness id>:<session id>`, unique across every harness |
+| `harness` | string | The reader's `id` |
+| `title` | string | The harness's own title, or the first line of the first prompt |
+| `project` / `projectPath` | string | The repo folder's name and absolute path |
+| `worktree` | string | Worktree name, or `''` |
+| `cwd`, `gitBranch` | string | Where it's working |
+| `model`, `effort` | string | The harness's own ids, as recorded |
+| `status` | string | `asking`, `working`, `delegating`, `done`, `error`, or `idle`. See [Done, needing you, and archived](#done-needing-you-and-archived) |
+| `live` | boolean | A process for it is running now. A harness that keeps no record of its processes reports `true` while a turn is open |
+| `startedAt`, `lastActivityAt` | number | Epoch ms |
+| `tool` | `{ name, startedAt }` or `null` | The tool running right now, only while working or delegating |
+| `tokens` | `{ input, output, cacheRead, cacheWrite }` or `null` | Totals for the session's own thread. `input` leaves out cache reads and writes |
+| `context` | `{ used, limit }` or `null` | Tokens in the window after the last reply; `limit` is `0` when unknown |
+| `costUsd` | number or `null` | Spend as the harness records it; `null` when it doesn't |
+| `lines` | `{ added, removed }` or `null` | Lines changed, as the harness records it |
+| `plan` | `{ total, done, current }` or `null` | Plan progress, if the agent keeps one |
+| `subagents` | number | Subagents still working for it |
+| `awaiting` | `[{ id, title }]` | Claude Code only: other sessions it asked to hear from that are still busy, by their own `id`. Either this or `subagents` makes an idle session `delegating`. Other harnesses leave it out |
+| `prompts` | number or `null` | Prompts typed in this session |
+
+`null` means "this harness doesn't record it". Threadgauge shows "—" instead of guessing.
+
+### Done, needing you, and archived
+
+These follow the session readers in `../harnesses/`, so Threadgauge and Threadnauts count a
+thread the same way.
+- **Done** means the turn ended and you haven't read the reply. After that it's `idle`.
+  - **Where the harness records reading, that decides:** Codex's read receipts, Hermes's
+    `last_read_at`, and OpenCode 2.x's `time_viewed`.
+  - **Claude Code** counts a reply as unread when the Claude app's record of the thread changed
+    after you last focused it. A live session that handed its turn back in the last 30 minutes
+    is done either way, as the session reader's is.
+  - **Everywhere else,** a terminal-only Claude Code session included, a turn is done for 30
+    minutes after it ends. Not knowing isn't the same as read.
+- **Needing you** also covers a Claude Code turn the Claude app marked `blocked`, unless
+  subagents or other sessions are still out. `delegating` comes first.
+- **Archived** sessions are left out, and so are Claude Code sessions deleted in the app. Cursor
+  and Antigravity keep no archive record, so theirs always show.
+
+## The `Detail`
+
+| Field | Type | What it means |
+| --- | --- | --- |
+| `id`, `sessionId` | string | The session's id, and the harness's own id for it |
+| `source` | string | The transcript or database it was read from |
+| `models` | `[{ model, tokens, costUsd }]` | Tokens, and spend where recorded, per model |
+| `contextParts` | `{ input, cacheRead, cacheWrite, output }` | What filled the context in the latest request: new input, cache reads, cache writes, and its output. They add up to the session's `context.used`. `null` for Cursor, Antigravity, and Hermes |
+| `history` | `[{ at, context, output }]` | Context and output after each reply, the newest 600 |
+| `compactions` | `[{ at, before, after }]` | When the context was compacted, and its size before and after |
+| `activity` | `[{ id, name, target, input, path, line, startedAt, endedAt, running, error, errorText }]` | The newest 100 tool calls. `target` is a short file path, command, or search, never the output. `input` is the full command, or the call's input as JSON without file contents, cut to 2,000 characters. `path` and `line` are the file a call names, relative to the session's folder, and its line where known. `errorText` is the start of a failed call's own error output, cut to 500 characters. Any of these is `null` when the harness doesn't record it |
+| `tools` | `[{ name, calls, errors, ms }]` | Every call in the session, per tool |
+| `plan` | `[{ content, status }]` | Every plan step; `[]` when the agent kept none |
+| `subagents` | `[{ id, name, type, status, model, tokens, tool, startedAt, lastActivityAt }]` | Every subagent it started, finished or not |
+| `files` | `[{ path, added, removed, edits, line, hunks }]` | Lines changed per file, with paths relative to the session's folder. `line` is where its latest change starts. `hunks` (`[{ line, oldLine, lines, cut }]`) are its newest 5 changes as diff lines, each with at most 60 lines of 240 characters, and `cut` counts the lines left out. Only the 25 most recently edited files keep hunks; older ones have `[]`. `line` and `hunks` are `null` when the harness doesn't record them, and a hunk's `line` is `null` when the patch has no line numbers |
+| `prompts` | `[{ at, text }]` | The newest 50 prompts, each cut to 2,000 characters, with line breaks kept |
+| `errors` | `[{ at, message }]` | The newest 20 API errors and failed turns, each cut to 500 characters |
+
+Again, a `null` field means the harness doesn't record it. The shared helpers for building one
+(`startCall`, `endCall`, `toolTarget`, `keepNewest`, `fileList`, and the limits) are in
+`../lib/telemetry-fields.mjs`.
+
+| Harness | Where its details come from | `null` |
+| --- | --- | --- |
+| Claude Code | The transcript the scan already reads, collected as it goes (`transcriptReader({ detail: true })`), plus every subagent transcript and its `.meta.json`. Hunks come from each edit's `structuredPatch`, and a failed call's error text from its tool result | — |
+| Codex | The rollout state: calls and their exit codes, per-file lines and hunks from patches, and each `token_count`. Subagents are the child rollouts. A failed command's error text is its output | `compactions`. Hunks have no line numbers |
+| Cursor | The transcript state. A call's start is when it was first read | `history`, `models`, `files`, `compactions`. A call has no end time or error |
+| Antigravity CLI | Transcript steps, each ended by the next, with prompts from `history.jsonl` | `history`, `models`, `files`, `subagents`, `compactions`. A call has no input or file |
+| Hermes | One query for the compression chain: tool calls joined to their results, user messages, and child sessions | `history`, `files`, `compactions`. A call has no error |
+| OpenCode, Kilo Code | One query for the session's messages and tool parts. Files are the 1.x per-turn diffs; a failed call's error text is its `state.error` | `compactions`; `files` on 2.x and when Kilo kept no diffs; `hunks` always |
+
+## What each harness records
+
+Only Claude Code was checked against a real install. The others were written from each
+harness's source code, or, for the closed ones, from what other open-source tools parse, and
+tested against fake installs. Recheck them when a harness changes its format.
+
+| Harness | What the reader takes, and from where | Not on disk, so `null` |
+| --- | --- | --- |
+| Claude Code | Transcripts, the live session records, the model catalog cache, and the Claude app's own record of each thread, for whether you've read it, whether its turn is waiting on you, and whether it's archived (`../lib/claude-desktop.mjs`). Spend is every reply's usage priced at Anthropic's list prices (`../lib/anthropic-prices.mjs`), the way Claude Code's own `/usage` total is computed, subagents included. Lines are counted from Edit and Write results and the files shell commands changed. The `cost-state` records Claude Code writes are a fallback only, for a model with no list price: they're written now and then, and they cover a whole process, which can span several sessions | — |
+| Codex | Rollouts, plus the writer lock each loaded thread holds. Tokens and context come from `token_count`. Lines are counted from patches that applied. Renames come from `session_index.jsonl` and the state database, which also says what's archived and what you've read | Spend. An open approval prompt can't be told apart from a running command; only a question to you (`request_user_input`) shows as needing you |
+| Cursor | Agent transcripts: status from `turn_ended`, the tool last called, the todo list, and subagents | Tokens, context, model, spend, lines, and tool start times (the start is when the record appeared) |
+| Antigravity CLI | The transcript, written after each turn ends; the prompt history, whose newer prompt shows a turn underway; and the `task.md` checklist | Tokens, context, model, spend, lines, the current tool, and subagents. They're only in the protobuf conversation database, which isn't read |
+| Hermes | `state.db`: token and spend columns added up across compaction segments, turn leases, the newest todo list, and the tool calls with no result yet. Context limits come from `context_length_cache.yaml` | Lines. Needing you shows only through the activity label, which Hermes updates at most once a minute |
+| OpenCode | `opencode.db`, both the 1.x tables and 2.x's `session_v2`; a session in both keeps the newer copy. Totals come from the session row's usage columns, context from the last reply that produced output, and limits from `models.json` (1.x) or the `kv` catalog (2.x). Lines are the per-turn diff summaries (1.x). Needing you is a running `question` tool | Lines on 2.x. A pending permission prompt looks like any running tool |
+| Kilo Code | `kilo.db`, the same 1.x tables as OpenCode. Its `summary_*` columns are live, so they give lines | As OpenCode 1.x |
+
+## Ground rules
+
+- **Read-only.** A reader opens files for reading and nothing else. `test/read-only.test.mjs`
+  checks this folder along with `harnesses/` and `lib/`.
+- **Only the user's own home directory.** Never read from or run anything inside another app's
+  bundle.
+- **Read incrementally.** Transcripts grow to tens of megabytes, so keep a byte offset per file
+  and parse only what was added. `jsonlFollower` in `../lib/jsonl-follower.mjs` does that for any
+  JSONL transcript, and Claude Code's go through `../lib/claude-transcript.mjs`. A transcript that
+  shrank was rewritten: start it over.
+- **Open databases read-only, and check columns first.** `withReadOnly` in `../lib/sqlite.mjs`
+  opens one and closes it again. Check a column with `columnsOf` before a query names it, so a
+  column a harness renames costs one field instead of the whole harness.
+- **Expect half-written lines.** A session being written right now is normal. Hold a partial
+  last line until its newline arrives, and skip a record that won't parse.
+- **Never read secrets.** Claude Code keeps `*.key` files beside its session records. Read only
+  the `.json` files.

package/telemetry/antigravity.mjs

@@ -0,0 +1,268 @@
+import fsp from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { exists, jsonLines, listDirs } from '../lib/fsutil.mjs'
+import { jsonlFollower } from '../lib/jsonl-follower.mjs'
+import {
+  DETAIL_LIMITS,
+  RECENT_MS,
+  activityDetail,
+  clip,
+  clipBlock,
+  emptyActivity,
+  keepNewest,
+  planItems,
+  planSummary,
+  startCall,
+  text,
+  titleFromPrompt,
+} from '../lib/telemetry-fields.mjs'
+
+const ACTIVE_WINDOW_MS = 30 * 60 * 1000
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+const TRANSCRIPTS = [
+  ['.system_generated', 'logs', 'transcript_full.jsonl'],
+  ['.system_generated', 'logs', 'transcript.jsonl'],
+  ['transcript.jsonl'],
+]
+const CHECKLIST = /^\s*[-*]\s+\[([ xX/])\]\s+(.+?)\s*$/
+const CHECK_STATUS = { ' ': 'pending', '/': 'in_progress', x: 'completed', X: 'completed' }
+
+function contentText(content) {
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return ''
+  return content.map((p) => (typeof p === 'string' ? p : text(p?.text) || text(p?.input_text))).filter(Boolean).join('\n')
+}
+
+function userText(record) {
+  const raw = contentText(record?.content || record?.message?.content || '')
+  const query = /<USER_REQUEST>\s*([\s\S]*?)\s*<\/USER_REQUEST>/i.exec(raw)
+  return (query ? query[1] : raw.replace(/<[a-z_]+>[\s\S]*?<\/[a-z_]+>/gi, ' ')).trim()
+}
+
+function workspaceOf(record) {
+  const m = /active workspaces, each defined by a URI[\s\S]*?\[(.*?)\]\s*->/i.exec(contentText(record?.content))
+  return text(record?.cwd) || (m && path.isAbsolute(m[1]) ? m[1] : '')
+}
+
+function epochMs(value) {
+  if (typeof value === 'number') return value < 1e11 ? value * 1000 : value
+  const t = Date.parse(text(value))
+  return Number.isNaN(t) ? 0 : t
+}
+
+const isPrompt = (record) => record?.type === 'USER_INPUT' || record?.source === 'USER_EXPLICIT' || record?.role === 'user'
+
+const REPLY_STEPS = new Set(['PLANNER_RESPONSE', 'ERROR_MESSAGE'])
+
+function stepName(type) {
+  const words = text(type).toLowerCase().replace(/_+/g, ' ').trim()
+  return words ? `${words[0].toUpperCase()}${words.slice(1)}` : 'Step'
+}
+
+function emptyTranscript() {
+  return { firstPrompt: '', cwd: '', startedAt: 0, prompts: 0, failed: false, activity: emptyActivity(), lastStep: '', promptList: [], errors: [] }
+}
+
+function closeStep(state, at) {
+  const call = state.lastStep ? state.activity.calls.findLast((c) => c.id === state.lastStep) : null
+  state.lastStep = ''
+  if (!call || !at || call.endedAt) return
+  call.endedAt = Math.max(at, call.startedAt)
+  const tool = state.activity.tools.get(call.name)
+  if (tool) tool.ms += call.endedAt - call.startedAt
+}
+
+function applyRecord(state, record) {
+  const at = epochMs(record.created_at)
+  if (at && !state.startedAt) state.startedAt = at
+  if (isPrompt(record)) {
+    closeStep(state, 0)
+    const prompt = userText(record)
+    if (prompt) {
+      state.prompts++
+      state.firstPrompt ||= prompt
+      keepNewest(state.promptList, { at, text: clipBlock(prompt, DETAIL_LIMITS.promptText) }, DETAIL_LIMITS.prompts)
+    }
+    state.cwd ||= workspaceOf(record)
+  } else if (record.type) {
+    closeStep(state, at)
+    const failed = record.status === 'ERROR' || record.type === 'ERROR_MESSAGE'
+    if (!REPLY_STEPS.has(record.type)) {
+      const id = String(record.step_index ?? `${at}:${state.activity.calls.length}`)
+      const call = startCall(state.activity, { id, name: stepName(record.type), startedAt: at, running: false })
+      if (call) {
+        call.error = failed
+        if (failed) state.activity.tools.get(call.name).errors++
+        state.lastStep = id
+      }
+    }
+    if (failed) {
+      const message = userText(record) || `${stepName(record.type)} failed`
+      keepNewest(state.errors, { at, message: clip(message, DETAIL_LIMITS.errorText) }, DETAIL_LIMITS.errors)
+    }
+  }
+  if (record.status) state.failed = record.status === 'ERROR' || record.type === 'ERROR_MESSAGE'
+}
+
+export function parseChecklist(markdown) {
+  const steps = []
+  for (const line of text(markdown).split(/\r?\n/)) {
+    const m = CHECKLIST.exec(line)
+    if (m) steps.push({ content: m[2], status: CHECK_STATUS[m[1]] })
+  }
+  return steps
+}
+
+export function antigravity({
+  home = process.env.THREADCRUMBS_ANTIGRAVITY_HOME || process.env.ANTIGRAVITY_HOME || path.join(os.homedir(), '.gemini', 'antigravity-cli'),
+  now = Date.now,
+} = {}) {
+  const brainDir = path.join(home, 'brain')
+  const historyFile = path.join(home, 'history.jsonl')
+  const transcripts = jsonlFollower({ empty: emptyTranscript, apply: applyRecord })
+  const plans = new Map()
+  let history = { mtime: -1, byId: new Map() }
+  let known = new Set()
+
+  async function readHistory() {
+    const stat = await fsp.stat(historyFile).catch(() => null)
+    if (!stat) return new Map()
+    if (stat.mtimeMs === history.mtime) return history.byId
+    const byId = new Map()
+    for (const row of jsonLines(await fsp.readFile(historyFile, 'utf8').catch(() => ''))) {
+      const id = text(row?.conversationId)
+      if (!id) continue
+      const entry = byId.get(id) || { prompts: 0, firstAt: 0, lastAt: 0, first: '', workspace: '', list: [] }
+      const at = epochMs(row.timestamp)
+      entry.prompts++
+      entry.first ||= text(row.display)
+      if (text(row.display).trim()) keepNewest(entry.list, { at, text: clipBlock(row.display, DETAIL_LIMITS.promptText) }, DETAIL_LIMITS.prompts)
+      entry.firstAt ||= at
+      entry.lastAt = Math.max(entry.lastAt, at)
+      if (!entry.workspace && path.isAbsolute(text(row.workspace))) entry.workspace = row.workspace
+      byId.set(id, entry)
+    }
+    history = { mtime: stat.mtimeMs, byId }
+    return byId
+  }
+
+  async function readPlan(sessionDir) {
+    const file = path.join(sessionDir, 'task.md')
+    const stat = await fsp.stat(file).catch(() => null)
+    if (!stat) return null
+    const hit = plans.get(file)
+    if (hit && hit.mtime === stat.mtimeMs) return hit.plan
+    const plan = parseChecklist(await fsp.readFile(file, 'utf8').catch(() => ''))
+    plans.set(file, { mtime: stat.mtimeMs, plan })
+    return plan
+  }
+
+  async function transcriptOf(sessionDir) {
+    for (const parts of TRANSCRIPTS) {
+      const file = path.join(sessionDir, ...parts)
+      const stat = await fsp.stat(file).catch(() => null)
+      if (stat?.size) return { file, stat }
+    }
+    return null
+  }
+
+  async function scanSessions() {
+    const at = now()
+    const prompts = await readHistory()
+    const ids = new Set((await listDirs(brainDir)).map((d) => path.basename(d)).filter((id) => UUID.test(id)))
+    for (const [id, entry] of prompts) if (UUID.test(id) && at - entry.lastAt < ACTIVE_WINDOW_MS) ids.add(id)
+    const sessions = []
+    const seenPlans = new Set()
+    const listed = new Set()
+    for (const id of ids) {
+      const sessionDir = path.join(brainDir, id)
+      const found = await transcriptOf(sessionDir)
+      const typed = prompts.get(id)
+      const transcriptAt = found ? Math.floor(found.stat.mtimeMs) : 0
+      const lastActivityAt = Math.max(transcriptAt, typed?.lastAt || 0)
+      if (at - lastActivityAt > RECENT_MS) continue
+      let state = emptyTranscript()
+      if (found) {
+        try {
+          state = await transcripts.read(found.file, found.stat)
+        } catch {
+          continue
+        }
+      }
+      seenPlans.add(path.join(sessionDir, 'task.md'))
+      listed.add(id)
+      const plan = await readPlan(sessionDir)
+      const open = Boolean(typed) && typed.lastAt > transcriptAt && at - typed.lastAt < ACTIVE_WINDOW_MS
+      let status
+      if (open) status = 'working'
+      else if (state.failed) status = 'error'
+      else status = at - lastActivityAt < ACTIVE_WINDOW_MS ? 'done' : 'idle'
+      const cwd = state.cwd || typed?.workspace || ''
+      const prompt = state.firstPrompt || typed?.first || ''
+      sessions.push({
+        id: `antigravity:${id}`,
+        harness: 'antigravity',
+        title: (prompt ? titleFromPrompt(prompt) : '') || 'Untitled session',
+        project: cwd ? path.basename(cwd.replace(/\\/g, '/')) : 'unknown',
+        projectPath: cwd,
+        worktree: '',
+        cwd,
+        gitBranch: '',
+        model: '',
+        effort: '',
+        status,
+        live: open,
+        startedAt: state.startedAt || typed?.firstAt || transcriptAt,
+        lastActivityAt,
+        tool: null,
+        tokens: null,
+        context: null,
+        costUsd: null,
+        lines: null,
+        plan: planSummary(plan),
+        subagents: 0,
+        prompts: Math.max(state.prompts, typed?.prompts || 0),
+      })
+    }
+    transcripts.sweep()
+    for (const file of plans.keys()) if (!seenPlans.has(file)) plans.delete(file)
+    known = listed
+    return sessions
+  }
+
+  async function sessionDetail(key) {
+    const id = String(key).replace(/^antigravity:/, '')
+    if (!known.has(id)) return null
+    const sessionDir = path.join(brainDir, id)
+    const found = await transcriptOf(sessionDir)
+    const state = (found && (await transcripts.read(found.file, found.stat).catch(() => null))) || emptyTranscript()
+    const typed = (await readHistory()).get(id)
+    return {
+      id: `antigravity:${id}`,
+      sessionId: id,
+      source: found?.file || historyFile,
+      models: null,
+      history: null,
+      compactions: null,
+      contextParts: null,
+      ...activityDetail(state.activity),
+      plan: planItems(await readPlan(sessionDir)),
+      subagents: null,
+      files: null,
+      prompts: (typed?.list.length ? typed.list : state.promptList).map((p) => ({ ...p })),
+      errors: state.errors.map((e) => ({ ...e })),
+    }
+  }
+
+  return {
+    id: 'antigravity',
+    name: 'Antigravity CLI',
+    detect: async () => (await exists(brainDir)) || (await exists(historyFile)),
+    watchRoots: () => [home],
+    scanSessions,
+    sessionDetail,
+  }
+}
+
+export default antigravity()