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

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

@@ -1,111 +0,0 @@
-import { afterEach, beforeAll, beforeEach, describe, expect, test } from 'bun:test'
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import type { Finalizer } from '../recorder'
-import type { SessionInfo } from '../store'
-import type { TelemetryEvent } from '../types'
-
-// ASTRALE_HOME must be set before the store/paths singleton is first imported.
-process.env.ASTRALE_HOME = mkdtempSync(join(tmpdir(), 'astrale-tele-recorder-'))
-
-let beginInvocation: (argv: string[]) => Finalizer
-let eventsPath: (id: string) => string
-let listSessions: () => SessionInfo[]
-let sessionsRoot: () => string
-let configPath: string
-
-const SESSION = 'rec-test'
-
-let work: string
-let cwd0: string
-
-beforeAll(async () => {
-  const recorder = await import('../recorder')
-  const store = await import('../store')
-  beginInvocation = recorder.beginInvocation
-  eventsPath = store.eventsPath
-  listSessions = store.listSessions
-  sessionsRoot = store.sessionsRoot
-  configPath = join(process.env.ASTRALE_HOME!, 'config.json')
-})
-
-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 })
-  rmSync(configPath, { force: true })
-  delete process.env.ASTRALE_TELEMETRY
-  process.env.ASTRALE_SESSION = SESSION
-  work = mkdtempSync(join(tmpdir(), 'astrale-tele-recwork-'))
-  cwd0 = process.cwd()
-  process.chdir(work)
-})
-
-afterEach(() => {
-  process.chdir(cwd0)
-  rmSync(work, { recursive: true, force: true })
-})
-
-function readEvents(id: string): TelemetryEvent[] {
-  return readFileSync(eventsPath(id), 'utf-8')
-    .split('\n')
-    .filter(Boolean)
-    .map((l) => JSON.parse(l) as TelemetryEvent)
-}
-
-describe('beginInvocation', () => {
-  test('appends one valid, parseable event with redacted argv', () => {
-    const cwd = process.cwd()
-    const finalize = beginInvocation(['node', 'astrale', 'get', '--token', 'abc', 'x'])
-    finalize(0)
-
-    const events = readEvents(SESSION)
-    expect(events).toHaveLength(1)
-    const [e] = events
-    expect(e.v).toBe(1)
-    expect(e.surface).toBe('cli')
-    expect(e.exitCode).toBe(0)
-    expect(e.argv).toEqual(['get', '--token', '<redacted>', 'x'])
-    expect(e.cwd).toBe(cwd)
-    expect(e.root).toBe(cwd)
-    expect(typeof e.ts).toBe('string')
-    expect(typeof e.durationMs).toBe('number')
-    expect('errorName' in e).toBe(false)
-  })
-
-  test('records exitCode and errorName on failure', () => {
-    beginInvocation(['node', 'astrale', 'call', 'foo'])(1, 'AuthError')
-    const [e] = readEvents(SESSION)
-    expect(e.exitCode).toBe(1)
-    expect(e.errorName).toBe('AuthError')
-  })
-
-  test('appends a second line on a second invocation', () => {
-    beginInvocation(['node', 'astrale', 'query'])(0)
-    beginInvocation(['node', 'astrale', 'whoami'])(0)
-    expect(readEvents(SESSION)).toHaveLength(2)
-  })
-
-  test('writes nothing for help/version-only invocations', () => {
-    beginInvocation(['node', 'astrale', '--help'])(0)
-    beginInvocation(['node', 'astrale', '--version'])(0)
-    beginInvocation(['node', 'astrale', '--cli-version'])(0)
-    beginInvocation(['node', 'astrale'])(0)
-    expect(listSessions()).toHaveLength(0)
-  })
-
-  test('writes nothing when disabled via ASTRALE_TELEMETRY', () => {
-    process.env.ASTRALE_TELEMETRY = '0'
-    beginInvocation(['node', 'astrale', 'get', 'x'])(0)
-    expect(listSessions()).toHaveLength(0)
-    expect(existsSync(eventsPath(SESSION))).toBe(false)
-  })
-
-  test('writes nothing when disabled via config telemetry.enabled=false', () => {
-    writeFileSync(configPath, JSON.stringify({ telemetry: { enabled: false } }))
-    beginInvocation(['node', 'astrale', 'get', 'x'])(0)
-    expect(listSessions()).toHaveLength(0)
-  })
-})

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

@@ -1,79 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { redactArgv } from '../redact'
-
-describe('redactArgv', () => {
-  test('redacts the value following a secret flag', () => {
-    expect(redactArgv(['--token', 'abc123', '--json'])).toEqual(['--token', '<redacted>', '--json'])
-  })
-
-  test('matches secret substrings in flag names, case-insensitively', () => {
-    expect(redactArgv(['--api-Token', 's', '--Bearer', 'b', '--jwk', 'k'])).toEqual([
-      '--api-Token',
-      '<redacted>',
-      '--Bearer',
-      '<redacted>',
-      '--jwk',
-      '<redacted>',
-    ])
-  })
-
-  test('redacts the value part of inline k=v secret args', () => {
-    expect(redactArgv(['--secret=hunter2', 'password=p', '--verbose'])).toEqual([
-      '--secret=<redacted>',
-      'password=<redacted>',
-      '--verbose',
-    ])
-  })
-
-  test('leaves non-secret flags and their values intact', () => {
-    expect(redactArgv(['query', '--limit', '3', '--format=json'])).toEqual([
-      'query',
-      '--limit',
-      '3',
-      '--format=json',
-    ])
-  })
-
-  test('truncates any arg longer than 200 chars to 200 + ellipsis', () => {
-    const long = 'x'.repeat(300)
-    const [only] = redactArgv([long])
-    expect(only).toBe('x'.repeat(200) + '…')
-    expect([...only].length).toBe(201)
-  })
-
-  test('a secret value is redacted before length matters', () => {
-    expect(redactArgv(['--password', 'y'.repeat(500)])).toEqual(['--password', '<redacted>'])
-  })
-
-  test('caps the array at 40 items with a …+N marker', () => {
-    const args = Array.from({ length: 45 }, (_, i) => `a${i}`)
-    const out = redactArgv(args)
-    expect(out.length).toBe(41)
-    expect(out.slice(0, 40)).toEqual(args.slice(0, 40))
-    expect(out[40]).toBe('…+5')
-  })
-
-  test('does not cap at exactly 40 items', () => {
-    const args = Array.from({ length: 40 }, (_, i) => `a${i}`)
-    expect(redactArgv(args)).toEqual(args)
-  })
-
-  test('a trailing secret flag with no value does not throw', () => {
-    expect(redactArgv(['call', '--token'])).toEqual(['call', '--token'])
-  })
-})
-
-describe('secret-shaped values', () => {
-  test('positional JWT is redacted wherever it appears', () => {
-    const jwt =
-      'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U'
-    expect(redactArgv(['call', '/x::y', jwt])).toEqual(['call', '/x::y', '<redacted>'])
-    expect(redactArgv(['call', `body=Bearer ${jwt}`])[1]).toBe('body=Bearer <redacted>')
-  })
-  test('sk- style api key is redacted, plain paths are not', () => {
-    expect(redactArgv(['x', 'sk-abcdefghijklmnop1234'])).toEqual(['x', '<redacted>'])
-    const p = '/Users/someone/Documents/astrale/workspace/cli/src/telemetry/adapters/index.ts'
-    expect(redactArgv([p])).toEqual([p])
-  })
-})

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

@@ -1,267 +0,0 @@
-import { afterEach, beforeAll, beforeEach, 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'
-
-import type { SweepOptions, SweepResult } from '../retention'
-import type { RetentionBudget } from '../settings'
-import type { SessionScan } from '../store'
-
-// Set the home before the paths singleton is captured (dynamic imports below).
-process.env.ASTRALE_HOME = mkdtempSync(join(tmpdir(), 'astrale-tele-retention-'))
-
-let sweepByAge: (sessions: readonly SessionScan[], options?: SweepOptions) => SweepResult
-let sweepToBudget: (sessions: readonly SessionScan[], options?: SweepOptions) => SweepResult
-let sweepStore: (options?: SweepOptions) => SweepResult
-let tidySession: (id: string, options?: { keepPrompt?: boolean }) => string[]
-let scanSessions: () => SessionScan[]
-let sessionDir: (id: string) => string
-let sessionBytes: (id: string) => number
-let sessionsRoot: () => string
-
-const DAY = 24 * 60 * 60 * 1000
-const BUDGET: RetentionBudget = { maxAgeMs: 30 * DAY, maxBytes: 10_000 }
-
-beforeAll(async () => {
-  ;({ sweepByAge, sweepToBudget, sweepStore, tidySession } = await import('../retention'))
-  ;({ scanSessions, sessionDir, sessionBytes, sessionsRoot } = await import('../store'))
-})
-
-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 })
-  delete process.env.ASTRALE_TELEMETRY_MAX_AGE_DAYS
-  delete process.env.ASTRALE_TELEMETRY_MAX_BYTES
-})
-
-afterEach(() => {
-  rmSync(sessionsRoot(), { recursive: true, force: true })
-})
-
-type Seed = { ageMs?: number; analyzed?: boolean; bytes?: number; events?: boolean }
-
-function seed(id: string, { ageMs = 0, analyzed = false, bytes = 0, events = true }: Seed): void {
-  const dir = sessionDir(id)
-  mkdirSync(dir, { recursive: true })
-  writeFileSync(join(dir, 'meta.json'), JSON.stringify({ id, root: '/w', explicit: false }))
-  if (bytes > 0) writeFileSync(join(dir, 'report.md'), 'x'.repeat(bytes))
-  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)
-}
-
-const alive = (id: string): boolean => existsSync(sessionDir(id))
-
-describe('sweepByAge', () => {
-  test('drops sessions past the age bound whether or not they were analyzed', () => {
-    seed('old-analyzed', { ageMs: 40 * DAY, analyzed: true })
-    seed('old-unanalyzed', { ageMs: 40 * DAY })
-    seed('recent-analyzed', { ageMs: 2 * DAY, analyzed: true })
-    seed('recent-unanalyzed', { ageMs: 2 * DAY })
-
-    const { removed } = sweepByAge(scanSessions(), { budget: BUDGET })
-
-    expect(removed.sort()).toEqual(['old-analyzed', 'old-unanalyzed'])
-    expect(alive('recent-analyzed')).toBe(true)
-    expect(alive('recent-unanalyzed')).toBe(true)
-  })
-
-  test('never touches a session with no events — that is the invocation running now', () => {
-    seed('no-events-yet', { events: false })
-    expect(sweepByAge(scanSessions(), { budget: BUDGET }).removed).toEqual([])
-    expect(alive('no-events-yet')).toBe(true)
-  })
-
-  test('honours the removal cap so a backlog drains over several runs', () => {
-    for (let i = 0; i < 5; i++) seed(`stale-${i}`, { ageMs: 40 * DAY, analyzed: true })
-    expect(sweepByAge(scanSessions(), { budget: BUDGET, limit: 2 }).removed).toHaveLength(2)
-    expect(scanSessions()).toHaveLength(3)
-  })
-
-  test('respects the configured age bound', () => {
-    seed('week-old', { ageMs: 8 * DAY, analyzed: true })
-    const strict: RetentionBudget = { ...BUDGET, maxAgeMs: 7 * DAY }
-    expect(sweepByAge(scanSessions(), { budget: strict }).removed).toEqual(['week-old'])
-  })
-
-  test('protected ids survive the age bound', () => {
-    seed('old-but-mine', { ageMs: 40 * DAY, analyzed: true })
-    const options = { budget: BUDGET, protect: new Set(['old-but-mine']) }
-    expect(sweepByAge(scanSessions(), options).removed).toEqual([])
-    expect(alive('old-but-mine')).toBe(true)
-  })
-})
-
-describe('sweepToBudget', () => {
-  test('does nothing while the store fits', () => {
-    seed('small', { ageMs: DAY, analyzed: true, bytes: 100 })
-    expect(sweepToBudget(scanSessions(), { budget: BUDGET }).removed).toEqual([])
-    expect(alive('small')).toBe(true)
-  })
-
-  test('evicts oldest-first until the store is back under budget', () => {
-    seed('oldest', { ageMs: 5 * DAY, analyzed: true, bytes: 4_000 })
-    seed('middle', { ageMs: 3 * DAY, analyzed: true, bytes: 4_000 })
-    seed('newest', { ageMs: DAY, analyzed: true, bytes: 4_000 })
-
-    // 3 × ~4 KB against a 5 KB bound: two must go, and the newest must stay.
-    const { removed } = sweepToBudget(scanSessions(), { budget: { ...BUDGET, maxBytes: 5_000 } })
-
-    expect(removed).toEqual(['oldest', 'middle'])
-    expect(alive('newest')).toBe(true)
-  })
-
-  test('evicts analyzed sessions before unanalyzed ones of any age', () => {
-    seed('unanalyzed-oldest', { ageMs: 9 * DAY, bytes: 6_000 })
-    seed('analyzed-newest', { ageMs: DAY, analyzed: true, bytes: 6_000 })
-
-    expect(sweepToBudget(scanSessions(), { budget: BUDGET }).removed).toEqual(['analyzed-newest'])
-    expect(alive('unanalyzed-oldest')).toBe(true)
-  })
-
-  test('falls through to unanalyzed sessions when analyzed ones are not enough', () => {
-    seed('unanalyzed-old', { ageMs: 9 * DAY, bytes: 6_000 })
-    seed('analyzed-old', { ageMs: 8 * DAY, analyzed: true, bytes: 6_000 })
-    seed('unanalyzed-new', { ageMs: DAY, bytes: 6_000 })
-
-    const { removed } = sweepToBudget(scanSessions(), { budget: BUDGET })
-
-    expect(removed).toEqual(['analyzed-old', 'unanalyzed-old'])
-    expect(alive('unanalyzed-new')).toBe(true)
-  })
-
-  test('never evicts an open session, even when that leaves the store over budget', () => {
-    // No age offset → inside IDLE_WINDOW_MS → open.
-    seed('open-and-huge', { analyzed: true, bytes: 20_000 })
-    expect(sweepToBudget(scanSessions(), { budget: BUDGET }).removed).toEqual([])
-    expect(alive('open-and-huge')).toBe(true)
-  })
-
-  test('never evicts a protected session', () => {
-    seed('just-analyzed', { ageMs: DAY, analyzed: true, bytes: 20_000 })
-    const options = { budget: BUDGET, protect: new Set(['just-analyzed']) }
-    expect(sweepToBudget(scanSessions(), options).removed).toEqual([])
-  })
-
-  test('counts nested analyzer output — a session is bounded by all it holds', () => {
-    seed('nested', { ageMs: DAY, analyzed: true, bytes: 100 })
-    mkdirSync(join(sessionDir('nested'), 'scratch'), { recursive: true })
-    writeFileSync(join(sessionDir('nested'), 'scratch', 'dump.txt'), 'x'.repeat(5_000))
-
-    expect(sessionBytes('nested')).toBeGreaterThan(5_000)
-  })
-})
-
-describe('sweepStore', () => {
-  test('applies age first, then trims what survives to the size bound', () => {
-    seed('expired', { ageMs: 40 * DAY, analyzed: true, bytes: 6_000 })
-    seed('fresh-big', { ageMs: 2 * DAY, analyzed: true, bytes: 6_000 })
-    seed('fresh-small', { ageMs: DAY, analyzed: true, bytes: 100 })
-
-    // Age alone frees 6 KB, leaving ~6.1 KB — already under the 10 KB bound,
-    // so the size pass must find nothing left to do.
-    expect(sweepStore({ budget: BUDGET }).removed).toEqual(['expired'])
-    expect(alive('fresh-big')).toBe(true)
-    expect(alive('fresh-small')).toBe(true)
-  })
-
-  test('reads its budget from the environment when none is passed', () => {
-    process.env.ASTRALE_TELEMETRY_MAX_AGE_DAYS = '1'
-    seed('two-days-old', { ageMs: 2 * DAY, analyzed: true })
-    expect(sweepStore().removed).toEqual(['two-days-old'])
-  })
-})
-
-describe('sweepStore tidying', () => {
-  test('tidies analyzed survivors, so the bound applies to sessions already on disk', () => {
-    seed('store-tidy', { ageMs: DAY, analyzed: true, bytes: 100 })
-    writeFileSync(join(sessionDir('store-tidy'), 'calls.txt'), 'x'.repeat(50_000))
-
-    sweepStore({ budget: BUDGET })
-
-    expect(existsSync(join(sessionDir('store-tidy'), 'calls.txt'))).toBe(false)
-    expect(existsSync(join(sessionDir('store-tidy'), 'report.md'))).toBe(true)
-  })
-
-  test('an unanalyzed session is left alone — its analyzer may still be running', () => {
-    seed('store-pending', { ageMs: DAY, bytes: 100 })
-    writeFileSync(join(sessionDir('store-pending'), 'analyzer-prompt.md'), '# in flight')
-
-    sweepStore({ budget: BUDGET })
-
-    expect(existsSync(join(sessionDir('store-pending'), 'analyzer-prompt.md'))).toBe(true)
-  })
-
-  test('scratch is tidied before the size bound is measured, not after', () => {
-    // 60 KB of scratch against a 10 KB budget: tidying first brings the store
-    // back under on its own, so nothing should be evicted.
-    seed('store-bloated', { ageMs: DAY, analyzed: true, bytes: 100 })
-    writeFileSync(join(sessionDir('store-bloated'), 'calls.txt'), 'x'.repeat(60_000))
-
-    expect(sweepStore({ budget: BUDGET }).removed).toEqual([])
-    expect(existsSync(sessionDir('store-bloated'))).toBe(true)
-  })
-
-  test('a failed analysis keeps its prompt through the sweep', () => {
-    const dir = sessionDir('store-failed')
-    seed('store-failed', { ageMs: DAY, analyzed: true })
-    writeFileSync(
-      join(dir, '.analyzed'),
-      JSON.stringify({ analyzedAt: new Date().toISOString(), outcome: 'error', note: 'boom' }),
-    )
-    writeFileSync(join(dir, 'analyzer-prompt.md'), '# what we asked')
-
-    sweepStore({ budget: BUDGET })
-
-    expect(existsSync(join(dir, 'analyzer-prompt.md'))).toBe(true)
-  })
-})
-
-describe('tidySession', () => {
-  test('removes what the analyzer left behind, keeps the durable artifacts', () => {
-    const dir = sessionDir('tidy-scratch')
-    seed('tidy-scratch', { ageMs: DAY, analyzed: true, bytes: 100 })
-    writeFileSync(join(dir, 'analyzer.log'), 'exit 0')
-    writeFileSync(join(dir, 'analyzer-prompt.md'), '# prompt')
-    // Scratch: the analyzer runs with Write in here and answers to nobody.
-    writeFileSync(join(dir, 'calls.txt'), 'x'.repeat(50_000))
-    mkdirSync(join(dir, 'notes'), { recursive: true })
-    writeFileSync(join(dir, 'notes', 'draft.md'), 'scratch')
-
-    const removed = tidySession('tidy-scratch')
-
-    expect(removed.sort()).toEqual(['analyzer-prompt.md', 'calls.txt', 'notes'])
-    for (const keep of ['meta.json', 'events.jsonl', 'report.md', '.analyzed', 'analyzer.log']) {
-      expect(existsSync(join(dir, keep))).toBe(true)
-    }
-    expect(existsSync(join(dir, 'notes'))).toBe(false)
-  })
-
-  test('keepPrompt spares the prompt — the failing case is when it matters', () => {
-    const dir = sessionDir('tidy-failed')
-    seed('tidy-failed', { ageMs: DAY, analyzed: true })
-    writeFileSync(join(dir, 'analyzer-prompt.md'), '# prompt')
-    writeFileSync(join(dir, 'scratch.json'), '{}')
-
-    expect(tidySession('tidy-failed', { keepPrompt: true })).toEqual(['scratch.json'])
-    expect(existsSync(join(dir, 'analyzer-prompt.md'))).toBe(true)
-  })
-
-  test('a session with nothing to tidy is left exactly as it was', () => {
-    seed('tidy-clean', { ageMs: DAY, analyzed: true, bytes: 10 })
-    expect(tidySession('tidy-clean')).toEqual([])
-    expect(existsSync(sessionDir('tidy-clean'))).toBe(true)
-  })
-
-  test('a missing session directory is a no-op, not an error', () => {
-    expect(tidySession('tidy-absent')).toEqual([])
-  })
-})

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

@@ -1,166 +0,0 @@
-import { afterEach, beforeAll, beforeEach, describe, expect, test } from 'bun:test'
-import {
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  utimesSync,
-  writeFileSync,
-} from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import type { ResolvedSession } from '../session'
-import type { SessionMeta } from '../types'
-
-/** Seed an ambient session on disk with a chosen id + last-activity age. */
-function seedAmbient(id: string, root: string, ageMs: number): void {
-  mkdirSync(sessionDir(id), { recursive: true })
-  const meta: SessionMeta = { id, root, explicit: false, createdAt: new Date().toISOString() }
-  writeFileSync(metaPath(id), JSON.stringify(meta))
-  writeFileSync(eventsPath(id), '{}\n')
-  const when = new Date(Date.now() - ageMs)
-  utimesSync(eventsPath(id), when, when)
-}
-
-// Set ASTRALE_HOME before the store/paths singleton is first evaluated (below,
-// via dynamic import). All on-disk access goes through the store helpers so it
-// stays consistent whichever home the singleton captured.
-process.env.ASTRALE_HOME = mkdtempSync(join(tmpdir(), 'astrale-tele-session-'))
-
-let resolveSession: (cwd: string) => ResolvedSession
-let ensureSession: (cwd: string) => ResolvedSession
-let eventsPath: (id: string) => string
-let metaPath: (id: string) => string
-let sessionDir: (id: string) => string
-let sessionsRoot: () => string
-let IDLE_WINDOW_MS: number
-
-let work: string
-
-beforeAll(async () => {
-  const session = await import('../session')
-  const store = await import('../store')
-  resolveSession = session.resolveSession
-  ensureSession = session.ensureSession
-  eventsPath = store.eventsPath
-  metaPath = store.metaPath
-  sessionDir = store.sessionDir
-  sessionsRoot = store.sessionsRoot
-  IDLE_WINDOW_MS = store.IDLE_WINDOW_MS
-})
-
-beforeEach(() => {
-  if (!sessionsRoot().startsWith(tmpdir())) throw new Error('refusing to clean a non-tmp home')
-  rmSync(sessionsRoot(), { recursive: true, force: true })
-  delete process.env.ASTRALE_SESSION
-  work = mkdtempSync(join(tmpdir(), 'astrale-tele-work-'))
-})
-
-afterEach(() => {
-  rmSync(work, { recursive: true, force: true })
-})
-
-describe('resolveSession — ambient', () => {
-  test('reuses an open ambient session bucketed to the same root', () => {
-    // An old-stamp id proves reuse: a fresh mint would carry the current minute.
-    const existing = 'amb-deadbeef-200001010000'
-    seedAmbient(existing, work, 5 * 60_000)
-
-    const r = resolveSession(work)
-
-    expect(r).toEqual({ id: existing, root: work, explicit: false })
-  })
-
-  test('mints a fresh session once the previous one is idle', () => {
-    const existing = 'amb-deadbeef-200001010000'
-    seedAmbient(existing, work, IDLE_WINDOW_MS + 60_000)
-
-    const r = resolveSession(work)
-
-    expect(r.id).not.toBe(existing)
-    expect(r.explicit).toBe(false)
-    expect(r.id).toMatch(/^amb-[0-9a-f]{8}-\d{12}$/)
-  })
-
-  test('does not reuse a session bucketed to a different root', () => {
-    const existing = 'amb-deadbeef-200001010000'
-    seedAmbient(existing, work, 5 * 60_000)
-
-    const other = mkdtempSync(join(tmpdir(), 'astrale-tele-other-'))
-    try {
-      expect(resolveSession(other).id).not.toBe(existing)
-    } finally {
-      rmSync(other, { recursive: true, force: true })
-    }
-  })
-
-  test('ensureSession creates then reuses one session across calls', () => {
-    const first = ensureSession(work)
-    const second = ensureSession(work)
-    expect(second.id).toBe(first.id)
-    expect(first.id).toMatch(/^amb-[0-9a-f]{8}-\d{12}$/)
-  })
-})
-
-describe('resolveSession — root bucketing', () => {
-  test('buckets by the nearest .git ancestor, not cwd', () => {
-    mkdirSync(join(work, '.git'), { recursive: true })
-    const deep = join(work, 'sub', 'deep')
-    mkdirSync(deep, { recursive: true })
-
-    expect(resolveSession(deep).root).toBe(work)
-  })
-
-  test('falls back to cwd when there is no git root', () => {
-    expect(resolveSession(work).root).toBe(work)
-  })
-})
-
-describe('resolveSession — explicit ASTRALE_SESSION', () => {
-  test('honors an explicit id, sanitizing unsafe chars and capping at 64', () => {
-    process.env.ASTRALE_SESSION = 'my/weird:sess!!'
-    const r = resolveSession(work)
-    expect(r).toEqual({ id: 'myweirdsess', root: work, explicit: true })
-
-    process.env.ASTRALE_SESSION = 'a'.repeat(80)
-    expect(resolveSession(work).id).toBe('a'.repeat(64))
-  })
-
-  test('falls through to ambient when the id is empty after sanitizing', () => {
-    process.env.ASTRALE_SESSION = '///'
-    const r = resolveSession(work)
-    expect(r.explicit).toBe(false)
-    expect(r.id).toMatch(/^amb-/)
-  })
-})
-
-describe('ensureSession', () => {
-  test('creates the session dir and a readable meta.json once', () => {
-    const r = ensureSession(work)
-
-    expect(existsSync(metaPath(r.id))).toBe(true)
-    const meta = JSON.parse(readFileSync(metaPath(r.id), 'utf-8')) as SessionMeta
-    expect(meta.id).toBe(r.id)
-    expect(meta.root).toBe(work)
-    expect(meta.explicit).toBe(false)
-    expect(typeof meta.createdAt).toBe('string')
-  })
-})
-
-describe('analyzed sessions are never reused', () => {
-  test('an open ambient session with an .analyzed marker gets a fresh mint', async () => {
-    const { markerPath } = await import('../store')
-    const root = join(work, 'analyzed-root')
-    mkdirSync(root, { recursive: true })
-    seedAmbient('amb-analyzed-open', root, 0) // fresh mtime → open
-    writeFileSync(
-      markerPath('amb-analyzed-open'),
-      JSON.stringify({ analyzedAt: new Date().toISOString(), outcome: 'reported' }),
-    )
-    const resolved = resolveSession(root)
-    expect(resolved.id).not.toBe('amb-analyzed-open')
-    expect(resolved.id.startsWith('amb-')).toBe(true)
-  })
-})