@astrale-os/cli 1.0.0-beta.32 → 1.0.0-beta.43

package/src/telemetry/__tests__/settings.test.ts

@@ -1,102 +0,0 @@
-import { afterEach, beforeAll, beforeEach, describe, expect, test } from 'bun:test'
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import type { RetentionBudget } from '../settings'
-
-// Set the home before the paths singleton is captured (dynamic imports below).
-process.env.ASTRALE_HOME = mkdtempSync(join(tmpdir(), 'astrale-tele-settings-'))
-
-let retentionBudget: () => RetentionBudget
-let telemetryEnabled: () => boolean
-let DEFAULT_MAX_AGE_DAYS: number
-let DEFAULT_MAX_BYTES: number
-let configPath: string
-
-const DAY = 24 * 60 * 60 * 1000
-
-beforeAll(async () => {
-  const settings = await import('../settings')
-  retentionBudget = settings.retentionBudget
-  telemetryEnabled = settings.telemetryEnabled
-  DEFAULT_MAX_AGE_DAYS = settings.DEFAULT_MAX_AGE_DAYS
-  DEFAULT_MAX_BYTES = settings.DEFAULT_MAX_BYTES
-  configPath = join(process.env.ASTRALE_HOME!, 'config.json')
-})
-
-function writeConfig(telemetry: unknown): void {
-  writeFileSync(configPath, JSON.stringify({ telemetry }))
-}
-
-beforeEach(() => {
-  rmSync(configPath, { force: true })
-  delete process.env.ASTRALE_TELEMETRY
-  delete process.env.ASTRALE_TELEMETRY_MAX_AGE_DAYS
-  delete process.env.ASTRALE_TELEMETRY_MAX_BYTES
-})
-
-afterEach(() => {
-  rmSync(configPath, { force: true })
-  delete process.env.ASTRALE_TELEMETRY_MAX_AGE_DAYS
-  delete process.env.ASTRALE_TELEMETRY_MAX_BYTES
-})
-
-describe('retentionBudget', () => {
-  test('defaults when nothing is configured', () => {
-    expect(retentionBudget()).toEqual({
-      maxAgeMs: DEFAULT_MAX_AGE_DAYS * DAY,
-      maxBytes: DEFAULT_MAX_BYTES,
-    })
-  })
-
-  test('reads both bounds from config.json', () => {
-    writeConfig({ maxAgeDays: 7, maxBytes: 1_048_576 })
-    expect(retentionBudget()).toEqual({ maxAgeMs: 7 * DAY, maxBytes: 1_048_576 })
-  })
-
-  test('env wins over config', () => {
-    writeConfig({ maxAgeDays: 7, maxBytes: 1_048_576 })
-    process.env.ASTRALE_TELEMETRY_MAX_AGE_DAYS = '2'
-    process.env.ASTRALE_TELEMETRY_MAX_BYTES = '4096'
-    expect(retentionBudget()).toEqual({ maxAgeMs: 2 * DAY, maxBytes: 4096 })
-  })
-
-  test('a bad env value falls through to config rather than unbounding the store', () => {
-    writeConfig({ maxAgeDays: 7 })
-    process.env.ASTRALE_TELEMETRY_MAX_AGE_DAYS = 'soon'
-    expect(retentionBudget().maxAgeMs).toBe(7 * DAY)
-  })
-
-  test.each([
-    ['zero', 0],
-    ['negative', -1],
-    ['not a number', 'lots'],
-    ['null', null],
-  ])('%s config values fall back to the default', (_label, maxBytes) => {
-    writeConfig({ maxBytes })
-    expect(retentionBudget().maxBytes).toBe(DEFAULT_MAX_BYTES)
-  })
-
-  test('a broken config yields defaults instead of throwing', () => {
-    writeFileSync(configPath, '{ not json')
-    expect(retentionBudget().maxBytes).toBe(DEFAULT_MAX_BYTES)
-  })
-})
-
-describe('telemetryEnabled', () => {
-  test('on by default, and unaffected by retention keys', () => {
-    writeConfig({ maxAgeDays: 7 })
-    expect(telemetryEnabled()).toBe(true)
-  })
-
-  test('off via config', () => {
-    writeConfig({ enabled: false })
-    expect(telemetryEnabled()).toBe(false)
-  })
-
-  test.each(['0', 'false', 'off', 'OFF', ' off '])('off via ASTRALE_TELEMETRY=%p', (value) => {
-    process.env.ASTRALE_TELEMETRY = value
-    expect(telemetryEnabled()).toBe(false)
-  })
-})

package/src/telemetry/__tests__/store-scan.test.ts

@@ -1,128 +0,0 @@
-import { beforeAll, beforeEach, describe, expect, test } from 'bun:test'
-import { mkdirSync, mkdtempSync, rmSync, utimesSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import type { SessionInfo, SessionScan } from '../store'
-
-// Set the home before the paths singleton is captured (dynamic imports below).
-process.env.ASTRALE_HOME = mkdtempSync(join(tmpdir(), 'astrale-tele-scan-'))
-
-let scanSessions: (now?: number) => SessionScan[]
-let listSessions: (now?: number) => SessionInfo[]
-let readMeta: (id: string) => { root: string; explicit: boolean } | null
-let sessionDir: (id: string) => string
-let sessionsRoot: () => string
-let IDLE_WINDOW_MS: number
-
-const DAY = 24 * 60 * 60 * 1000
-
-beforeAll(async () => {
-  const store = await import('../store')
-  scanSessions = store.scanSessions
-  listSessions = store.listSessions
-  readMeta = store.readMeta as typeof readMeta
-  sessionDir = store.sessionDir
-  sessionsRoot = store.sessionsRoot
-  IDLE_WINDOW_MS = store.IDLE_WINDOW_MS
-})
-
-beforeEach(() => {
-  // Destructive cleanup must be provably confined to this file's mkdtemp home.
-  if (!sessionsRoot().startsWith(tmpdir())) throw new Error('refusing to clean a non-tmp home')
-  rmSync(sessionsRoot(), { recursive: true, force: true })
-})
-
-type Seed = { ageMs?: number; analyzed?: boolean; events?: boolean; root?: string }
-
-function seed(id: string, { ageMs = 0, analyzed = false, events = true, root = '/w' }: Seed): void {
-  const dir = sessionDir(id)
-  mkdirSync(dir, { recursive: true })
-  writeFileSync(join(dir, 'meta.json'), JSON.stringify({ id, root, explicit: false }))
-  if (analyzed) {
-    writeFileSync(
-      join(dir, '.analyzed'),
-      JSON.stringify({ analyzedAt: new Date().toISOString(), outcome: 'reported' }),
-    )
-  }
-  if (!events) return
-  writeFileSync(join(dir, 'events.jsonl'), '{}\n')
-  const when = new Date(Date.now() - ageMs)
-  utimesSync(join(dir, 'events.jsonl'), when, when)
-}
-
-describe('scanSessions', () => {
-  test('reports the same id set, ordering and open/closed verdict as listSessions', () => {
-    seed('scan-oldest', { ageMs: 5 * DAY, analyzed: true })
-    seed('scan-middle', { ageMs: 2 * DAY })
-    seed('scan-open', {})
-
-    const scan = scanSessions()
-    const full = listSessions()
-
-    expect(scan.map((s) => s.id)).toEqual(full.map((s) => s.id))
-    expect(scan.map((s) => s.closed)).toEqual(full.map((s) => s.closed))
-    expect(scan.map((s) => s.lastEventAt?.getTime() ?? null)).toEqual(
-      full.map((s) => s.lastEventAt?.getTime() ?? null),
-    )
-  })
-
-  test('analyzed is presence of the marker, matching listSessions', () => {
-    seed('scan-done', { ageMs: DAY, analyzed: true })
-    seed('scan-pending', { ageMs: DAY })
-
-    const byId = new Map(scanSessions().map((s) => [s.id, s.analyzed]))
-    expect(byId.get('scan-done')).toBe(true)
-    expect(byId.get('scan-pending')).toBe(false)
-    expect(listSessions().map((s) => s.analyzed !== null)).toEqual(
-      listSessions().map((s) => byId.get(s.id)!),
-    )
-  })
-
-  test('an unparseable marker still counts as analyzed — presence is the fact', () => {
-    seed('scan-broken-marker', { ageMs: DAY })
-    writeFileSync(join(sessionDir('scan-broken-marker'), '.analyzed'), '{ not json')
-    expect(scanSessions()[0]?.analyzed).toBe(true)
-  })
-
-  test('a session with no events yet is neither closed nor dated', () => {
-    seed('scan-no-events', { events: false })
-    const [only] = scanSessions()
-    expect(only?.lastEventAt).toBeNull()
-    expect(only?.closed).toBe(false)
-  })
-
-  test('closed is decided by the idle window', () => {
-    seed('scan-just-inside', { ageMs: IDLE_WINDOW_MS - 60_000 })
-    seed('scan-just-outside', { ageMs: IDLE_WINDOW_MS + 60_000 })
-    const byId = new Map(scanSessions().map((s) => [s.id, s.closed]))
-    expect(byId.get('scan-just-inside')).toBe(false)
-    expect(byId.get('scan-just-outside')).toBe(true)
-  })
-
-  test('a missing store directory scans to an empty list', () => {
-    rmSync(sessionsRoot(), { recursive: true, force: true })
-    expect(scanSessions()).toEqual([])
-  })
-
-  test('dotfiles in the store root are not sessions', () => {
-    seed('scan-real', { ageMs: DAY })
-    mkdirSync(sessionsRoot(), { recursive: true })
-    writeFileSync(join(sessionsRoot(), '.analyzer.lock'), '{}')
-    expect(scanSessions().map((s) => s.id)).toEqual(['scan-real'])
-  })
-})
-
-describe('readMeta', () => {
-  test('returns the parsed meta for one session', () => {
-    seed('meta-one', { ageMs: DAY, root: '/workspace/alpha' })
-    expect(readMeta('meta-one')?.root).toBe('/workspace/alpha')
-  })
-
-  test('missing or broken meta reads as null rather than throwing', () => {
-    expect(readMeta('meta-absent')).toBeNull()
-    mkdirSync(sessionDir('meta-broken'), { recursive: true })
-    writeFileSync(join(sessionDir('meta-broken'), 'meta.json'), '{ not json')
-    expect(readMeta('meta-broken')).toBeNull()
-  })
-})

package/src/telemetry/__tests__/trigger.test.ts

@@ -1,78 +0,0 @@
-import { beforeAll, describe, expect, test } from 'bun:test'
-import { existsSync, mkdirSync, mkdtempSync, rmSync, utimesSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-// Set the home before the paths singleton is captured (dynamic imports below).
-process.env.ASTRALE_HOME = mkdtempSync(join(tmpdir(), 'astrale-tele-trigger-'))
-
-let maybeTriggerAnalysis: (argv: string[]) => void
-let sessionDir: (id: string) => string
-
-beforeAll(async () => {
-  ;({ maybeTriggerAnalysis } = await import('../trigger'))
-  ;({ sessionDir } = await import('../store'))
-  // Sibling test files mutate shared state (env vars, and recorder.test.ts
-  // leaves a telemetry-disabled config.json in the shared home) — own it here.
-  delete process.env.ASTRALE_TELEMETRY
-  delete process.env.ASTRALE_TELEMETRY_NO_TRIGGER
-  const { CONFIG_PATH } = await import('../../state/index')
-  rmSync(CONFIG_PATH, { force: true })
-})
-
-function seed(id: string, ageMs: number, analyzed: boolean): void {
-  const dir = sessionDir(id)
-  mkdirSync(dir, { recursive: true })
-  writeFileSync(join(dir, 'meta.json'), JSON.stringify({ id, root: '/w', explicit: false }))
-  writeFileSync(join(dir, 'events.jsonl'), '{}\n')
-  if (analyzed) {
-    writeFileSync(
-      join(dir, '.analyzed'),
-      JSON.stringify({ analyzedAt: new Date().toISOString(), outcome: 'reported' }),
-    )
-  }
-  const when = new Date(Date.now() - ageMs)
-  utimesSync(join(dir, 'events.jsonl'), when, when)
-}
-
-const DAY = 24 * 60 * 60 * 1000
-
-// NOTE: none of these seed a closed-unanalyzed session, so the trigger finds no
-// analysis target and no test here ever spawns a child process.
-describe('opportunistic GC', () => {
-  test('removes sessions past retention, keeps recent ones', () => {
-    seed('gc-old-analyzed', 40 * DAY, true)
-    seed('gc-recent-analyzed', 2 * DAY, true)
-    maybeTriggerAnalysis(['bun', 'astrale', 'status'])
-    expect(existsSync(sessionDir('gc-old-analyzed'))).toBe(false)
-    expect(existsSync(sessionDir('gc-recent-analyzed'))).toBe(true)
-  })
-
-  test('runs with telemetry disabled — switching it off must drain the store', () => {
-    seed('gc-off-old', 40 * DAY, true)
-    process.env.ASTRALE_TELEMETRY = '0'
-    try {
-      maybeTriggerAnalysis(['bun', 'astrale', 'status'])
-    } finally {
-      delete process.env.ASTRALE_TELEMETRY
-    }
-    expect(existsSync(sessionDir('gc-off-old'))).toBe(false)
-  })
-
-  test('runs on `session` commands, which are exempt from analysis only', () => {
-    seed('gc-session-cmd-old', 40 * DAY, true)
-    maybeTriggerAnalysis(['bun', 'astrale', 'session', 'list'])
-    expect(existsSync(sessionDir('gc-session-cmd-old'))).toBe(false)
-  })
-
-  test('honours a configured age bound', () => {
-    seed('gc-two-days', 2 * DAY, true)
-    process.env.ASTRALE_TELEMETRY_MAX_AGE_DAYS = '1'
-    try {
-      maybeTriggerAnalysis(['bun', 'astrale', 'status'])
-    } finally {
-      delete process.env.ASTRALE_TELEMETRY_MAX_AGE_DAYS
-    }
-    expect(existsSync(sessionDir('gc-two-days'))).toBe(false)
-  })
-})

package/src/telemetry/adapters/__tests__/claude-code.test.ts

@@ -1,89 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-import { mkdirSync, mkdtempSync, rmSync, utimesSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { claudeCodeAdapter } from '../claude-code'
-
-const ROOT = '/tmp/fake/proj'
-const MUNGED = '-tmp-fake-proj'
-
-let base: string
-
-function project(dir: string, file: string, mtime: Date): string {
-  const projPath = join(base, 'projects', dir)
-  mkdirSync(projPath, { recursive: true })
-  const p = join(projPath, file)
-  writeFileSync(p, '{"type":"user"}\n')
-  utimesSync(p, mtime, mtime)
-  return p
-}
-
-beforeEach(() => {
-  base = mkdtempSync(join(tmpdir(), 'cc-adapter-'))
-})
-afterEach(() => {
-  rmSync(base, { recursive: true, force: true })
-})
-
-describe('claudeCodeAdapter', () => {
-  test('detect is false without a projects dir, true with one', () => {
-    expect(claudeCodeAdapter(base).detect()).toBe(false)
-    mkdirSync(join(base, 'projects'), { recursive: true })
-    expect(claudeCodeAdapter(base).detect()).toBe(true)
-  })
-
-  test('matches the exact munged dir and subdir-prefixed dirs, excludes unrelated', async () => {
-    const now = new Date()
-    const wide = {
-      start: new Date(now.getTime() - 2 * 3600_000),
-      end: new Date(now.getTime() + 2 * 3600_000),
-    }
-    project(MUNGED, 'exact.jsonl', now)
-    project(`${MUNGED}-sub-deeper`, 'child.jsonl', now)
-    project('-other-unrelated-path', 'nope.jsonl', now)
-
-    const sessions = await claudeCodeAdapter(base).discover(ROOT, wide)
-    const ids = sessions.map((s) => s.sessionId).sort()
-    expect(ids).toEqual(['child', 'exact'])
-    for (const s of sessions) {
-      expect(s.harness).toBe('claude-code')
-      expect(s.sizeBytes).toBeGreaterThan(0)
-      expect(typeof s.endedAt).toBe('string')
-      expect(typeof s.startedAt).toBe('string')
-    }
-  })
-
-  test('window filtering: excludes a transcript whose span sits entirely after the window', async () => {
-    const t = Date.now()
-    const window = { start: new Date(t - 2 * 3600_000), end: new Date(t - 3600_000) }
-    project(MUNGED, 'inside.jsonl', new Date(t - 90 * 60_000))
-    project(MUNGED, 'after.jsonl', new Date(t - 30 * 60_000))
-
-    const ids = (await claudeCodeAdapter(base).discover(ROOT, window)).map((s) => s.sessionId)
-    expect(ids).toContain('inside')
-    expect(ids).not.toContain('after')
-  })
-
-  test('only *.jsonl files are considered', async () => {
-    const now = new Date()
-    const wide = {
-      start: new Date(now.getTime() - 3600_000),
-      end: new Date(now.getTime() + 3600_000),
-    }
-    project(MUNGED, 'keep.jsonl', now)
-    project(MUNGED, 'ignore.txt', now)
-
-    const ids = (await claudeCodeAdapter(base).discover(ROOT, wide)).map((s) => s.sessionId)
-    expect(ids).toEqual(['keep'])
-  })
-
-  test('never throws and returns [] when the projects dir is missing', async () => {
-    const now = new Date()
-    const sessions = await claudeCodeAdapter(join(base, 'does-not-exist')).discover(ROOT, {
-      start: new Date(now.getTime() - 3600_000),
-      end: now,
-    })
-    expect(sessions).toEqual([])
-  })
-})

package/src/telemetry/adapters/__tests__/codex.test.ts

@@ -1,138 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-import { mkdirSync, mkdtempSync, rmSync, utimesSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { codexAdapter } from '../codex'
-
-const ROOT = '/work/proj'
-const WINDOW = {
-  start: new Date('2026-07-10T00:00:00.000Z'),
-  end: new Date('2026-07-10T23:59:59.000Z'),
-}
-const IN_DAY = ['2026', '07', '10']
-
-let base: string
-
-function meta(cwd: string, timestamp = '2026-07-10T10:00:00.000Z'): string {
-  return JSON.stringify({
-    type: 'session_meta',
-    payload: { session_id: `sid-${cwd}`, timestamp, cwd, cli_version: '1.2.3' },
-  })
-}
-
-function rollout(
-  day: string[],
-  name: string,
-  firstLine: string,
-  mtime = new Date('2026-07-10T10:05:00.000Z'),
-): string {
-  const dir = join(base, 'sessions', ...day)
-  mkdirSync(dir, { recursive: true })
-  const p = join(dir, `rollout-${name}.jsonl`)
-  writeFileSync(p, `${firstLine}\n{"type":"response_item"}\n{"type":"event_msg"}\n`)
-  utimesSync(p, mtime, mtime)
-  return p
-}
-
-beforeEach(() => {
-  base = mkdtempSync(join(tmpdir(), 'codex-adapter-'))
-})
-afterEach(() => {
-  rmSync(base, { recursive: true, force: true })
-})
-
-describe('codexAdapter', () => {
-  test('detect follows the sessions dir', () => {
-    expect(codexAdapter(base).detect()).toBe(false)
-    mkdirSync(join(base, 'sessions'), { recursive: true })
-    expect(codexAdapter(base).detect()).toBe(true)
-  })
-
-  test('cwd filtering: exact root and subdir included, unrelated excluded', async () => {
-    rollout(IN_DAY, 'exact', meta(ROOT))
-    rollout(IN_DAY, 'sub', meta(`${ROOT}/packages/app`))
-    rollout(IN_DAY, 'sibling', meta('/work/project-x'))
-    rollout(IN_DAY, 'elsewhere', meta('/somewhere/else'))
-
-    const sessions = await codexAdapter(base).discover(ROOT, WINDOW)
-    const cwds = sessions.map((s) => s.cwd).sort()
-    expect(cwds).toEqual([ROOT, `${ROOT}/packages/app`])
-    for (const s of sessions) {
-      expect(s.harness).toBe('codex')
-      expect(s.sessionId).toBe(`sid-${s.cwd}`)
-      expect(s.startedAt).toBe('2026-07-10T10:00:00.000Z')
-      expect(typeof s.endedAt).toBe('string')
-      expect(s.sizeBytes).toBeGreaterThan(0)
-    }
-  })
-
-  test('window filtering: rollout with mtime before the window is excluded', async () => {
-    rollout(IN_DAY, 'in', meta(ROOT))
-    rollout(
-      IN_DAY,
-      'stale',
-      meta(ROOT, '2026-07-08T10:00:00.000Z'),
-      new Date('2026-07-08T10:00:00.000Z'),
-    )
-
-    const ids = (await codexAdapter(base).discover(ROOT, WINDOW)).map((s) => s.sessionId)
-    // both share the same synthetic session_id; assert exactly one survived
-    expect(ids.length).toBe(1)
-  })
-
-  test('date-shard pruning skips days outside the window', async () => {
-    rollout(['2026', '01', '01'], 'jan', meta(ROOT), new Date('2026-01-01T10:00:00.000Z'))
-    const ids = await codexAdapter(base).discover(ROOT, WINDOW)
-    expect(ids).toEqual([])
-  })
-
-  test('a corrupt first line is skipped without throwing', async () => {
-    rollout(IN_DAY, 'good', meta(ROOT))
-    rollout(IN_DAY, 'corrupt', '{ this is not json ]]]')
-
-    const sessions = await codexAdapter(base).discover(ROOT, WINDOW)
-    expect(sessions.length).toBe(1)
-    expect(sessions[0]?.cwd).toBe(ROOT)
-  })
-
-  test('never throws and returns [] when the sessions dir is missing', async () => {
-    expect(await codexAdapter(join(base, 'absent')).discover(ROOT, WINDOW)).toEqual([])
-  })
-})
-
-describe('codexAdapter large session_meta', () => {
-  test('first line larger than one read chunk still parses (real rollouts embed base_instructions)', async () => {
-    // Padding before cwd pushes it past the first 64 KB chunk boundary.
-    const huge = JSON.stringify({
-      type: 'session_meta',
-      payload: {
-        base_instructions: { text: 'x'.repeat(80 * 1024) },
-        session_id: 'sid-huge',
-        timestamp: '2026-07-10T10:00:00.000Z',
-        cwd: ROOT,
-        cli_version: '1.2.3',
-      },
-    })
-    rollout(IN_DAY, 'huge', huge)
-    const sessions = await codexAdapter(base).discover(ROOT, WINDOW)
-    expect(sessions.map((s) => s.sessionId)).toEqual(['sid-huge'])
-  })
-})
-
-describe('codexAdapter timezone shard boundary', () => {
-  test('rollout in the next local-date shard still matches a window ending today (UTC+ offsets)', async () => {
-    const w = {
-      start: new Date('2026-07-10T20:00:00.000Z'),
-      end: new Date('2026-07-10T23:00:00.000Z'),
-    }
-    rollout(
-      ['2026', '07', '11'],
-      'tzedge',
-      meta(ROOT, '2026-07-10T22:25:00.000Z'),
-      new Date('2026-07-10T22:30:00.000Z'),
-    )
-    const sessions = await codexAdapter(base).discover(ROOT, w)
-    expect(sessions.map((s) => s.transcriptPath.includes('tzedge'))).toEqual([true])
-  })
-})

package/src/telemetry/adapters/__tests__/index.test.ts

@@ -1,88 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-import { mkdirSync, mkdtempSync, rmSync, utimesSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { claudeCodeAdapter } from '../claude-code'
-import { codexAdapter } from '../codex'
-import { defaultAdapters, discoverAll } from '../index'
-
-const ROOT = '/work/proj'
-const WINDOW = {
-  start: new Date('2026-07-01T00:00:00.000Z'),
-  end: new Date(Date.now() + 86_400_000),
-}
-
-let ccBase: string
-let cxBase: string
-
-function seedClaude(mtime: Date): void {
-  const dir = join(ccBase, 'projects', '-work-proj')
-  mkdirSync(dir, { recursive: true })
-  const p = join(dir, 'cc-session.jsonl')
-  writeFileSync(p, '{"type":"user"}\n')
-  utimesSync(p, mtime, mtime)
-}
-
-function seedCodex(mtime: Date): void {
-  const dir = join(cxBase, 'sessions', '2026', '07', '10')
-  mkdirSync(dir, { recursive: true })
-  const p = join(dir, 'rollout-x.jsonl')
-  const line = JSON.stringify({
-    type: 'session_meta',
-    payload: { session_id: 'cx-session', timestamp: '2026-07-10T10:00:00.000Z', cwd: ROOT },
-  })
-  writeFileSync(p, `${line}\n`)
-  utimesSync(p, mtime, mtime)
-}
-
-beforeEach(() => {
-  ccBase = mkdtempSync(join(tmpdir(), 'cc-base-'))
-  cxBase = mkdtempSync(join(tmpdir(), 'cx-base-'))
-})
-afterEach(() => {
-  rmSync(ccBase, { recursive: true, force: true })
-  rmSync(cxBase, { recursive: true, force: true })
-})
-
-describe('discoverAll', () => {
-  test('defaultAdapters exposes both harnesses', () => {
-    expect(
-      defaultAdapters()
-        .map((a) => a.name)
-        .sort(),
-    ).toEqual(['claude-code', 'codex'])
-  })
-
-  test('merges detected adapters and sorts by endedAt descending', async () => {
-    seedClaude(new Date('2026-07-10T09:00:00.000Z'))
-    seedCodex(new Date('2026-07-10T11:00:00.000Z'))
-
-    const sessions = await discoverAll(
-      [claudeCodeAdapter(ccBase), codexAdapter(cxBase)],
-      ROOT,
-      WINDOW,
-    )
-    expect(sessions.map((s) => s.harness)).toEqual(['codex', 'claude-code'])
-  })
-
-  test('never throws when a base dir is missing; returns only the detected harness', async () => {
-    seedClaude(new Date('2026-07-10T09:00:00.000Z'))
-
-    const sessions = await discoverAll(
-      [claudeCodeAdapter(ccBase), codexAdapter(join(cxBase, 'absent'))],
-      ROOT,
-      WINDOW,
-    )
-    expect(sessions.map((s) => s.harness)).toEqual(['claude-code'])
-  })
-
-  test('returns [] when nothing is detected', async () => {
-    const sessions = await discoverAll(
-      [claudeCodeAdapter(join(ccBase, 'absent')), codexAdapter(join(cxBase, 'absent'))],
-      ROOT,
-      WINDOW,
-    )
-    expect(sessions).toEqual([])
-  })
-})