@xingular/harness 0.1.7 → 1.1.1

package/src/skills/registry.ts

@@ -1,413 +0,0 @@
-// Canonical skills, prompts, and rules under `<data root>/registry/`. Each item is a Markdown
-// file (a skill may also be a folder with `SKILL.md`) with optional `name`/`description`
-// frontmatter. These files are the single source of truth. Items are enabled globally and per
-// project; enabled items are loaded automatically, and any item can be retrieved on demand.
-//
-// Built-in items ship with the harness or the application that embeds it, in folders laid out
-// like `registry/`. They are read-only and on everywhere until a person switches one off; an
-// item of the same id in the data root replaces the built-in one.
-import { lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync } from 'node:fs'
-import { basename, dirname, join } from 'node:path'
-
-import { invalid } from '../core/errors'
-import * as frontmatter from '../core/frontmatter'
-import { atomicWrite, now, readJsonOr, safeRelative } from '../core/fs'
-import { findProject } from '../core/projects'
-import { compareText, lines, takeChars } from '../core/text'
-import * as store from '../memory/store'
-import * as attachments from '../plugins/attachments'
-
-export const KINDS = ['skills', 'prompts', 'rules'] as const
-export type RegistryKind = (typeof KINDS)[number]
-
-export interface RegistryItem {
-  /** `<kind>/<name>`, stable across edits. */
-  id: string
-  kind: string
-  name: string
-  description: string
-  path: string
-  /** Set on an item that ships with the harness or the application, not on a person's own. */
-  builtin?: true
-}
-
-/** The capability id used when this registry item is shown in the plugin catalogue. */
-export function contributionId(item: Pick<RegistryItem, 'id' | 'builtin'>): string {
-  return `${item.builtin ? 'included' : 'yours'}/${item.id}`
-}
-
-/** Limits registry items to the contributions frozen for a run. `undefined` means no limit. */
-export function limitToContributions(items: readonly RegistryItem[], contributions?: readonly string[]): RegistryItem[] {
-  if (contributions === undefined) return [...items]
-  const allowed = new Set(contributions)
-  return items.filter((item) => allowed.has(contributionId(item)))
-}
-
-export interface SkillBundleInput {
-  name: string
-  files: { path: string; content: string; encoding: 'utf8' | 'base64' }[]
-}
-
-const MAX_SKILL_BUNDLES = 20
-const MAX_SKILL_FILES = 100
-const MAX_SKILL_IMPORT_BYTES = 10 * 1024 * 1024
-
-let builtinDirs: string[] = []
-
-/** The folders built-in items are read from, each laid out like `registry/`. Later folders win. */
-export function configureBuiltins(directories: readonly string[]): void {
-  builtinDirs = [...directories]
-}
-
-function itemFrom(kind: string, stem: string, file: string): RegistryItem | null {
-  let text: string
-  try {
-    text = readFileSync(file, 'utf8')
-  } catch {
-    return null
-  }
-  const parsed = frontmatter.parse(text)
-  const name = parsed?.front.name
-  const description = parsed?.front.description
-  // A frontmatter block whose name or description is not text is treated as no frontmatter.
-  const usable = parsed !== null && (name === undefined || name === null || typeof name === 'string') && (description === undefined || description === null || typeof description === 'string')
-  const body = usable ? parsed.body : text
-  return {
-    id: `${kind}/${stem}`,
-    kind,
-    name: usable && typeof name === 'string' ? name : stem.replace(/[-_]/g, ' '),
-    description: usable && typeof description === 'string' ? description : takeChars(lines(body).find((line) => line.trim() && !line.startsWith('#')) ?? '', 160),
-    path: file
-  }
-}
-
-const stemOf = (name: string): string => (name.lastIndexOf('.') > 0 ? name.slice(0, name.lastIndexOf('.')) : name)
-
-/** The name and description of a skill or prompt file anywhere on disk, read the way a registry item is. */
-export function describeFile(file: string): { name: string; description: string } | null {
-  const stem = basename(file) === 'SKILL.md' ? basename(dirname(file)) : stemOf(basename(file))
-  const item = itemFrom('', stem, file)
-  return item && { name: item.name, description: item.description }
-}
-
-function itemsIn(directory: string): RegistryItem[] {
-  const items: RegistryItem[] = []
-  for (const kind of KINDS) {
-    let names: string[]
-    try {
-      names = readdirSync(join(directory, kind))
-    } catch {
-      continue
-    }
-    for (const name of names) {
-      const path = join(directory, kind, name)
-      const stem = stemOf(name)
-      if (stem.startsWith('.')) continue
-      const file = store.isDir(path) ? join(path, 'SKILL.md') : name.endsWith('.md') ? path : null
-      const item = file && itemFrom(kind, stem, file)
-      if (item) items.push(item)
-    }
-  }
-  return items
-}
-
-export function list(root: string): RegistryItem[] {
-  const items = new Map<string, RegistryItem>()
-  for (const directory of builtinDirs) for (const item of itemsIn(directory)) items.set(item.id, { ...item, builtin: true })
-  for (const item of itemsIn(join(root, 'registry'))) items.set(item.id, item)
-  return [...items.values()].sort((left, right) => compareText(left.id, right.id))
-}
-
-function enablementPath(root: string): string {
-  return join(root, 'config/registry-enabled.json')
-}
-
-/** Key for items enabled everywhere. Older data roots used `personal`, which is read the same way. */
-export const GLOBAL_KEY = 'global'
-
-/**
- * The registry's earlier enablement file as it is on disk: ids keyed by project id, or `global`
- * for everyone. The choices now live with every other plugin's (`plugins/attachments.ts`), which
- * reads this file until the first change is saved.
- */
-export function enablement(root: string): Record<string, unknown> {
-  const map = readJsonOr<unknown>(enablementPath(root), {})
-  return map && typeof map === 'object' && !Array.isArray(map) ? (map as Record<string, unknown>) : {}
-}
-
-export function enablementIds(map: Record<string, unknown>, key: string): string[] {
-  const ids = map[key]
-  return Array.isArray(ids) ? ids.filter((id): id is string => typeof id === 'string') : []
-}
-
-/** Built-in items a person switched off. Everything else built in is on everywhere. */
-export const BUILTIN_OFF_KEY = 'builtinOff'
-
-/** Whether an id names a registry item, as `<kind>/<name>`. */
-export const isItemId = (id: string): boolean => KINDS.some((kind) => id.startsWith(`${kind}/`))
-
-/**
- * Items active for a caller. A built-in is on until it is switched off; a person's own is off
- * until it is switched on, everywhere, for the caller's project, or for the calling agent.
- */
-export function enabledFor(root: string, projectId: string | null, agentId: string | null = null, contributions?: readonly string[]): RegistryItem[] {
-  if (contributions !== undefined) return limitToContributions(list(root), contributions)
-  const choices = attachments.load(root)
-  return list(root).filter((item) => attachments.attached(choices, [item.id], { agentId, projectId }, !!item.builtin))
-}
-
-/** An item's Markdown body without frontmatter. */
-export function itemBody(item: RegistryItem): string {
-  try {
-    const text = readFileSync(item.path, 'utf8')
-    return frontmatter.split(text)?.body ?? text
-  } catch {
-    return ''
-  }
-}
-
-export interface RegistryResources {
-  ids: string[]
-  skillPaths: string[]
-  promptPaths: string[]
-}
-
-/** What a Pi session needs to load enabled items natively. Rule text reaches the model through the compiled prompt. */
-export function resources(root: string, projectId: string | null, agentId: string | null = null, contributions?: readonly string[]): RegistryResources {
-  const items = enabledFor(root, projectId, agentId, contributions)
-  return {
-    ids: items.map((item) => item.id),
-    skillPaths: items.filter((item) => item.kind === 'skills').map((item) => item.path),
-    promptPaths: items.filter((item) => item.kind === 'prompts').map((item) => item.path)
-  }
-}
-
-// Prefix of the entries an earlier version of the harness linked into a Pi agent folder's `skills/`.
-const LINKED_SKILL_PREFIX = 'agentx-'
-
-function isLinkedSkill(path: string): boolean {
-  let meta
-  try {
-    meta = lstatSync(path)
-  } catch {
-    return false
-  }
-  if (meta.isSymbolicLink()) return true
-  if (!meta.isDirectory()) return false
-  // A single-file skill was linked as `agentx-<name>/SKILL.md` inside a folder the harness made.
-  try {
-    const entries = readdirSync(path)
-    return entries.length === 1 && entries[0] === 'SKILL.md' && lstatSync(join(path, 'SKILL.md')).isSymbolicLink()
-  } catch {
-    return false
-  }
-}
-
-/**
- * Removes the `agentx-<name>` links an earlier version kept in a terminal session's `skills/`
- * folder, leaving the user's own skills alone. Enabled skills now reach a session as paths.
- */
-export function removeLinkedSkills(skillsDir: string): void {
-  let names: string[]
-  try {
-    names = readdirSync(skillsDir)
-  } catch {
-    return
-  }
-  for (const name of names) {
-    const path = join(skillsDir, name)
-    if (!name.startsWith(LINKED_SKILL_PREFIX) || !isLinkedSkill(path)) continue
-    if (lstatSync(path).isSymbolicLink()) unlinkSync(path)
-    else rmSync(path, { recursive: true, force: true })
-  }
-}
-
-export interface RegistryState {
-  items: RegistryItem[]
-  enabled: Record<string, unknown>
-}
-
-/**
- * Enablement as a person sees it, in the earlier file's shape: ids keyed by project id, `global`
- * for everyone (built-ins that are on count as enabled everywhere), and the built-ins switched off.
- */
-function shown(items: readonly RegistryItem[], choices: attachments.Attachments): Record<string, unknown> {
-  const builtin = items.filter((item) => item.builtin).map((item) => item.id)
-  const off = choices.global.off.filter((id) => builtin.includes(id))
-  const global = choices.global.on.filter((id) => isItemId(id) && !builtin.includes(id))
-  const map: Record<string, unknown> = { [GLOBAL_KEY]: [...global, ...builtin.filter((id) => !off.includes(id))] }
-  for (const [projectId, entries] of Object.entries(choices.projects)) map[projectId] = entries.on.filter(isItemId)
-  if (off.length) map[BUILTIN_OFF_KEY] = off
-  return map
-}
-
-export function state(root: string): RegistryState {
-  const items = list(root)
-  return { items, enabled: shown(items, attachments.load(root)) }
-}
-
-/** Sets enabled items for a project, or globally when `projectId` is `null`. */
-export function setEnabled(root: string, projectId: string | null, ids: string[]): RegistryState {
-  if (projectId) findProject(root, projectId)
-  const items = list(root)
-  const unknown = ids.find((id) => !items.some((item) => item.id === id))
-  if (unknown !== undefined) throw invalid(`Unknown registry item ${unknown}.`)
-  const builtin = items.filter((item) => item.builtin).map((item) => item.id)
-  const choices = attachments.load(root)
-  const entries = projectId ? (choices.projects[projectId] ??= { on: [], off: [] }) : choices.global
-  // Only the registry's own ids are replaced; other plugins' choices in the same scope stay.
-  entries.on = [...entries.on.filter((id) => !isItemId(id)), ...ids.filter((id) => !builtin.includes(id))]
-  entries.off = entries.off.filter((id) => !isItemId(id) || (!ids.includes(id) && !(!projectId && builtin.includes(id))))
-  // A built-in left out of the global list was switched off.
-  if (!projectId) entries.off.push(...builtin.filter((id) => !ids.includes(id)))
-  attachments.save(root, choices)
-  return { items, enabled: shown(items, choices) }
-}
-
-function kindDir(root: string, kind: string): string {
-  if (!(KINDS as readonly string[]).includes(kind)) throw invalid('Unknown registry kind.')
-  return join(root, 'registry', kind)
-}
-
-/** Creates a starter item from a name: a Markdown file, or a skill folder with `SKILL.md`. */
-export function create(root: string, kind: string, rawName: string): RegistryState {
-  const directory = kindDir(root, kind)
-  const name = rawName.trim()
-  const slug = Array.from(name.toLowerCase(), (character) => (/^[a-z0-9]$/.test(character) ? character : '-')).join('').split('-').filter(Boolean).join('-')
-  if (!slug || slug.length > 64) throw invalid('Use a short name with letters or numbers.')
-  const description = 'Describe when to use this.'
-  const target = kind === 'skills' ? join(directory, slug) : join(directory, `${slug}.md`)
-  let exists = true
-  try {
-    lstatSync(target)
-  } catch {
-    exists = false
-  }
-  if (exists) throw invalid('An item with that name already exists.')
-  if (kind === 'skills') atomicWrite(join(target, 'SKILL.md'), `---\nname: ${slug}\ndescription: ${description}\n---\n\n# ${name}\n\nSteps the agent should follow.\n`)
-  else atomicWrite(target, `---\nname: ${name}\ndescription: ${description}\n---\n\n`)
-  return state(root)
-}
-
-/** Imports complete user-owned skill folders without replacing existing or built-in items. */
-export function importSkills(root: string, bundles: SkillBundleInput[]): RegistryState {
-  return importItems(root, 'skills', bundles)
-}
-
-/** Imports inert registry resources. Prompts and rules are single UTF-8 Markdown documents. */
-export function importItems(root: string, kind: RegistryKind, bundles: SkillBundleInput[]): RegistryState {
-  if (!Array.isArray(bundles) || bundles.length === 0 || bundles.length > MAX_SKILL_BUNDLES) {
-    throw invalid(`Import between 1 and ${MAX_SKILL_BUNDLES} skills at a time.`)
-  }
-
-  const directory = kindDir(root, kind)
-  mkdirSync(directory, { recursive: true })
-  const existing = new Set(list(root).map((item) => item.id))
-  const seen = new Set<string>()
-  let totalBytes = 0
-  const prepared = bundles.map((bundle) => {
-    if (!bundle || typeof bundle.name !== 'string' || !Array.isArray(bundle.files) || bundle.files.length === 0 || bundle.files.length > MAX_SKILL_FILES) {
-      throw invalid('Each skill needs a name and a bounded list of files.')
-    }
-    const name = bundle.name.trim()
-    if (name.length > 64) throw invalid('Use a skill name with at most 64 letters or numbers.')
-    const slug = Array.from(name.toLowerCase(), (character) => (/^[a-z0-9]$/.test(character) ? character : '-')).join('').split('-').filter(Boolean).join('-')
-    if (!slug || slug.length > 64) throw invalid('Use a skill name with at most 64 letters or numbers.')
-    const id = `${kind}/${slug}`
-    if (existing.has(id) || seen.has(id)) throw invalid(`The skill “${name}” already exists.`)
-    try {
-      lstatSync(join(directory, kind === 'skills' ? slug : `${slug}.md`))
-      throw invalid(`The skill “${name}” already exists.`)
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error
-    }
-    seen.add(id)
-
-    const files = new Map<string, Uint8Array>()
-    for (const file of bundle.files) {
-      if (!file || typeof file.path !== 'string' || file.path.length > 240 || typeof file.content !== 'string' || !['utf8', 'base64'].includes(file.encoding)) {
-        throw invalid(`The skill “${name}” contains an invalid file.`)
-      }
-      let relative: string
-      try {
-        relative = safeRelative(file.path)
-      } catch {
-        throw invalid(`The skill “${name}” contains a path outside its folder.`)
-      }
-      if (relative.includes('\0') || relative.split('/').some((part) => part.startsWith('.') || part.includes(':'))) {
-        throw invalid(`The skill “${name}” contains an unsupported file path.`)
-      }
-      const portablePath = relative.normalize('NFC').toLowerCase()
-      if ([...files.keys()].some((path) => path.normalize('NFC').toLowerCase() === portablePath)) throw invalid(`The skill “${name}” contains a duplicate file path.`)
-      let byteLength: number
-      if (file.encoding === 'base64') {
-        if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(file.content)) {
-          throw invalid(`The file “${relative}” is not valid base64.`)
-        }
-        if (file.content.length > Math.ceil(MAX_SKILL_IMPORT_BYTES / 3) * 4) throw invalid('The skill import is larger than 10 MiB.')
-        byteLength = Math.floor(file.content.length * 3 / 4) - (file.content.endsWith('==') ? 2 : file.content.endsWith('=') ? 1 : 0)
-      } else {
-        byteLength = Buffer.byteLength(file.content, 'utf8')
-      }
-      totalBytes += byteLength
-      if (totalBytes > MAX_SKILL_IMPORT_BYTES) throw invalid('The skill import is larger than 10 MiB.')
-      const bytes = file.encoding === 'base64' ? Buffer.from(file.content, 'base64') : Buffer.from(file.content, 'utf8')
-      if (file.encoding === 'base64' && bytes.toString('base64') !== file.content) throw invalid(`The file “${relative}” is not valid base64.`)
-      files.set(relative, bytes)
-    }
-    if (kind === 'skills' && !files.has('SKILL.md')) throw invalid(`The skill “${name}” must include SKILL.md at its root.`)
-    if (kind !== 'skills' && (bundle.files.length !== 1 || bundle.files[0].encoding !== 'utf8' || bundle.files[0].path !== 'CONTENT.md')) throw invalid('A prompt or rule must contain one UTF-8 CONTENT.md file.')
-    return { name, slug, files }
-  })
-
-  const staging = mkdtempSync(join(directory, '.agent-template-import-'))
-  const installed: string[] = []
-  try {
-    for (const bundle of prepared) {
-      const target = join(staging, bundle.slug)
-      for (const [relative, bytes] of bundle.files) {
-        const path = join(target, ...relative.split('/'))
-        mkdirSync(dirname(path), { recursive: true })
-        writeFileSync(path, bytes, { flag: 'wx' })
-      }
-    }
-    for (const bundle of prepared) {
-      const target = join(directory, kind === 'skills' ? bundle.slug : `${bundle.slug}.md`)
-      renameSync(kind === 'skills' ? join(staging, bundle.slug) : join(staging, bundle.slug, 'CONTENT.md'), target)
-      installed.push(target)
-    }
-  } catch (error) {
-    for (const target of installed) rmSync(target, { recursive: true, force: true })
-    throw error
-  } finally {
-    rmSync(staging, { recursive: true, force: true })
-  }
-  return state(root)
-}
-
-/**
- * Writes a skill, prompt, or rule (an accepted proposal), keeping an existing item's location.
- * The previous content and the new content are recorded as Wiki revisions of the item.
- */
-export function writeItem(root: string, kind: string, name: string, description: string, body: string, reason: string, actor = 'user'): string {
-  const plural = kind === 'skill' ? 'skills' : kind === 'prompt' ? 'prompts' : kind === 'rule' ? 'rules' : null
-  if (!plural) throw invalid('Only skills, prompts, and rules can be written.')
-  const stem = store.slug(name)
-  const id = `${plural}/${stem}`
-  const existing = list(root).find((item) => item.id === id)
-  // A built-in is never edited in place: the accepted text becomes the person's own item.
-  const path = existing && !existing.builtin ? existing.path : plural === 'skills' ? join(kindDir(root, plural), stem, 'SKILL.md') : join(kindDir(root, plural), `${stem}.md`)
-  const text = frontmatter.serialize({ name: plural === 'skills' ? stem : name.trim(), ...(description.trim() ? { description: description.trim() } : {}) }, body)
-  const wiki = store.wikiDir(root)
-  if (existing) {
-    try {
-      store.snapshot(wiki, id, readFileSync(existing.path, 'utf8'), actor, 'Before accepted proposal')
-    } catch {
-      // Nothing readable to keep.
-    }
-  }
-  atomicWrite(path, text)
-  store.snapshot(wiki, id, text, actor, reason)
-  store.log(wiki, `- ${now()} · ${actor} · ${existing ? 'updated' : 'created'} \`${id}\` · ${reason}`)
-  return id
-}

package/src/terminal/accountsMenu.test.ts

@@ -1,225 +0,0 @@
-import { mkdtempSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, describe, expect, it } from 'vitest'
-
-import type { AccountsOverview, AccountView } from '../accounts/store'
-import { memorySecretStore } from '../accounts/secrets'
-import { createHarness, type Harness } from '../harness'
-import { rootWithProject, writeFile } from '../../tests/helpers'
-import { SOCKET_ENV, TOKEN_ENV, socketCall, type SocketConnection } from './client'
-import { accountDetails, accountRows, resetIn, runAccountsMenu, type AccountsCall, type AccountsUi, type SessionAccount } from './accountsMenu'
-
-const open: Harness[] = []
-afterEach(async () => {
-  for (const harness of open.splice(0)) await harness.close()
-})
-
-/**
- * A person at the terminal. Each answer picks the first option that contains it (select), or
- * is the typed text (input), or is the yes/no (confirm). A select with no matching option fails
- * the test, so a changed menu label shows up here.
- */
-function person(answers: (string | boolean | undefined)[]) {
-  const shown: string[] = []
-  const said: { message: string; level?: string }[] = []
-  const next = () => answers.shift()
-  const ui: AccountsUi = {
-    select: async (title, options) => {
-      shown.push(title)
-      const answer = next()
-      if (answer === undefined) return undefined
-      const found = options.find((option) => option.includes(String(answer)))
-      if (!found) throw new Error(`No option containing "${answer}" in: ${options.join(' | ')}`)
-      return found
-    },
-    confirm: async (title) => {
-      shown.push(title)
-      return next() === true
-    },
-    input: async (title) => {
-      shown.push(title)
-      const answer = next()
-      return typeof answer === 'string' ? answer : undefined
-    },
-    notify: (message, level) => void said.push({ message, level })
-  }
-  return { ui, shown, said, remaining: () => answers.length }
-}
-
-function view(id: string, label: string, overrides: Partial<AccountView> = {}): AccountView {
-  return {
-    id,
-    provider: 'pi',
-    label,
-    authKind: 'subscription',
-    createdAt: '2026-10-01T00:00:00.000Z',
-    isDefault: false,
-    state: { health: 'unknown', signedIn: null, authMethod: null, plan: null, identity: null, limits: [], lastError: null, lastCheckedAt: null, cliVersion: null, capabilities: [], piProviders: [] },
-    ...overrides
-  }
-}
-
-describe('the accounts menu, without a terminal', () => {
-  it('numbers each account, marks the default and this session, and shows its health', () => {
-    const overview: AccountsOverview = {
-      accounts: [view('a1', 'Main', { isDefault: true, state: { ...view('a1', 'Main').state, health: 'limited' } }), view('a2', 'Spare')],
-      pools: [],
-      defaults: { pi: 'a1' }
-    }
-    const rows = accountRows(overview, { accountId: 'a2', label: 'Spare' } satisfies SessionAccount)
-    expect(rows.map((row) => row.label)).toEqual(['1. ● Main · Limit reached', '2. ○ Spare · Not checked · this session'])
-    expect(rows[1].account.id).toBe('a2')
-  })
-
-  it('says what the account can do and that providers do not report usage when none is reported', () => {
-    const text = accountDetails(view('a1', 'Main', { state: { ...view('a1', 'Main').state, health: 'auth_expired', piProviders: ['anthropic'], lastError: { category: 'rate_limited', message: 'Slow down.', at: '2026-10-01T00:00:00.000Z', resetsAt: null } } }))
-    expect(text).toContain('Health: Sign in again')
-    expect(text).toContain('Providers: anthropic')
-    expect(text).toContain('Last error: Slow down.')
-    expect(text).toContain('Pi providers do not report them.')
-  })
-
-  it('formats a reset time as a short countdown', () => {
-    const now = Date.parse('2026-10-01T00:00:00.000Z')
-    expect(resetIn('2026-10-01T00:05:00.000Z', now)).toBe('in 5m')
-    expect(resetIn('2026-10-01T02:30:00.000Z', now)).toBe('in 2h 30m')
-    expect(resetIn('2026-10-03T00:00:00.000Z', now)).toBe('in 2d')
-    expect(resetIn('2026-09-30T00:00:00.000Z', now)).toBe('now')
-  })
-})
-
-async function session() {
-  const root = rootWithProject()
-  const base = mkdtempSync(join(tmpdir(), 'accounts-menu-'))
-  writeFile(join(root, 'registry/rules/tests.md'), '---\nname: Run tests\ndescription: Always test.\n---\nAlways run the tests.\n')
-  const harness = createHarness({ dataRoot: root, stateDir: join(base, 'state'), secrets: memorySecretStore(), piProgram: () => '/opt/pi/bin/pi', assets: { node: '/opt/node', cli: '/opt/harness/cli.js', piExtension: '/opt/harness/terminal-pi.js' } })
-  open.push(harness)
-  const main = harness.accounts.create('Main', 'apiKey').accounts[0]
-  const spare = harness.accounts.create('Spare', 'apiKey').accounts.find((account) => account.label === 'Spare')!
-  const launch = await harness.terminals.prepare({ sessionId: 'term-1', accountId: main.id, cwd: base, sessionFolder: join(root, 'sessions', 'term-1') })
-  const connection: SocketConnection = { socket: String(launch.env[SOCKET_ENV]), token: String(launch.env[TOKEN_ENV]) }
-  // The extension claims the key before the model runs; the menu uses it for every change.
-  const { key } = await socketCall<{ key: string }>(connection, 'control.claim')
-  const call: AccountsCall = (method, params) => socketCall(connection, method, params ?? {}, 5_000, key)
-  return { harness, main, spare, connection, key, call }
-}
-
-describe('the accounts menu, over the session socket', () => {
-  it('refuses account calls from the shell token, and serves them to the extension with its key', async () => {
-    const { connection, key, main, harness } = await session()
-    await expect(socketCall(connection, 'accounts.list')).rejects.toMatchObject({ code: 'unauthorized' })
-    await expect(socketCall(connection, 'accounts.list', {}, 5_000, 'guessed')).rejects.toMatchObject({ code: 'unauthorized' })
-    await expect(socketCall(connection, 'accounts.deviceId')).rejects.toMatchObject({ code: 'unauthorized' })
-    const listed = await socketCall<AccountsOverview>(connection, 'accounts.list', {}, 5_000, key)
-    expect(listed.accounts.map((account) => account.id)).toContain(main.id)
-    expect(await socketCall<{ accountId: string; label: string }>(connection, 'accounts.session', {}, 5_000, key)).toEqual({ accountId: main.id, label: 'Main' })
-    expect(await socketCall(connection, 'accounts.deviceId', {}, 5_000, key)).toBe(await harness.accounts.installationDeviceId())
-  })
-
-  it('will not remove an account a running terminal is using, this session included', async () => {
-    const { call, main, spare, harness } = await session()
-    await expect(call('accounts.remove', { accountId: main.id })).rejects.toMatchObject({ code: 'account_in_use' })
-    expect(harness.accounts.find(main.id).id).toBe(main.id)
-    // An account with no terminal on it is removed as usual.
-    await call('accounts.remove', { accountId: spare.id })
-    expect(() => harness.accounts.find(spare.id)).toThrow()
-  })
-
-  it('makes an account the default from the menu', async () => {
-    const { call, harness, spare, main } = await session()
-    const { ui, said } = person(['Spare', 'Make default', 'Back', 'Done'])
-    expect(await runAccountsMenu(ui, call, { accountId: main.id, label: 'Main' })).toBeUndefined()
-    expect(harness.accounts.overview().defaults.pi).toBe(spare.id)
-    expect(said.map((entry) => entry.message)).toContain('Spare is the default for new sessions.')
-  })
-
-  it('switches this session to another account by ending Pi, and leaves the choice for the launcher', async () => {
-    const { call, harness, spare, main } = await session()
-    const { ui } = person(['Spare', 'Use for this session', true])
-    const outcome = await runAccountsMenu(ui, call, { accountId: main.id, label: 'Main' })
-    expect(outcome).toBe('relaunch')
-    expect(harness.terminals.takeRelaunch('term-1')).toEqual({ accountId: spare.id, nativeSessionId: null })
-    // Taken once: a second read finds nothing.
-    expect(harness.terminals.takeRelaunch('term-1')).toBeNull()
-  })
-
-  it('does not switch when the person declines the confirmation', async () => {
-    const { call, harness, spare, main } = await session()
-    const { ui } = person(['Spare', 'Use for this session', false, 'Back', 'Done'])
-    expect(await runAccountsMenu(ui, call, { accountId: main.id, label: 'Main' })).toBeUndefined()
-    expect(harness.terminals.takeRelaunch('term-1')).toBeNull()
-    expect(harness.accounts.find(spare.id).id).toBe(spare.id)
-  })
-})
-
-describe('signing in from the accounts menu', () => {
-  it('shows structured OAuth choices and returns the selected provider choice ID', async () => {
-    const overview: AccountsOverview = { accounts: [view('a1', 'Main')], pools: [], defaults: { pi: 'a1' } }
-    const answered: Record<string, unknown>[] = []
-    const statuses = [
-      { loginId: 'L2', revision: 1, status: 'running', events: [], prompt: { type: 'prompt', promptId: 'P2', prompt: { type: 'select', message: 'Select OpenAI Codex login method:', options: [{ id: 'device_code', label: 'Device code login' }, { id: 'browser', label: 'Browser login' }] } }, success: null, error: null, accountId: 'a1', provider: 'openai-codex', method: 'oauth' },
-      { loginId: 'L2', revision: 2, status: 'completed', events: [], prompt: null, success: true, error: null, accountId: 'a1', provider: 'openai-codex', method: 'oauth' }
-    ]
-    const call = (async (method: string, params?: Record<string, unknown>) => {
-      switch (method) {
-        case 'accounts.list':
-          return overview
-        case 'accounts.providers':
-          return [{ id: 'openai-codex', name: 'OpenAI Codex', oauth: true, oauthLabel: 'Sign in with ChatGPT', apiKey: false }]
-        case 'accounts.loginStart':
-          return { loginId: 'L2' }
-        case 'accounts.loginStatus':
-          return statuses.shift()
-        case 'accounts.loginRespond':
-          answered.push(params!)
-          return {}
-        default:
-          throw new Error(`unexpected ${method}`)
-      }
-    }) as unknown as AccountsCall
-    const script = person(['Main', 'Sign in', 'OpenAI Codex', 'Device code login', 'Back', 'Done'])
-
-    expect(await runAccountsMenu(script.ui, call, { accountId: 'a1', label: 'Main' })).toBeUndefined()
-
-    expect(answered).toEqual([{ loginId: 'L2', promptId: 'P2', value: 'device_code' }])
-    expect(script.shown).toContain('Select OpenAI Codex login method:')
-  })
-
-  it('follows a browser sign-in, answers its prompt, and reports the result', async () => {
-    const overview: AccountsOverview = { accounts: [view('a1', 'Main')], pools: [], defaults: { pi: 'a1' } }
-    const answered: Record<string, unknown>[] = []
-    const statuses = [
-      { loginId: 'L1', revision: 1, status: 'running', events: [{ type: 'auth_url', url: 'https://auth.example/start' }], prompt: null, success: null, error: null, accountId: 'a1', provider: 'anthropic', method: 'oauth' },
-      { loginId: 'L1', revision: 2, status: 'running', events: [], prompt: { type: 'prompt', promptId: 'P1', prompt: { type: 'secret', message: 'Paste the code', placeholder: null, options: null } }, success: null, error: null, accountId: 'a1', provider: 'anthropic', method: 'oauth' },
-      { loginId: 'L1', revision: 3, status: 'completed', events: [], prompt: null, success: true, error: null, accountId: 'a1', provider: 'anthropic', method: 'oauth' }
-    ]
-    const call = (async (method: string, params?: Record<string, unknown>) => {
-      switch (method) {
-        case 'accounts.list':
-          return overview
-        case 'accounts.session':
-          return { accountId: 'a1', label: 'Main' }
-        case 'accounts.providers':
-          return [{ id: 'anthropic', name: 'Anthropic', oauth: true, oauthLabel: 'Claude', apiKey: false }]
-        case 'accounts.loginStart':
-          expect(params).toEqual({ accountId: 'a1', provider: 'anthropic' })
-          return { loginId: 'L1' }
-        case 'accounts.loginStatus':
-          return statuses.shift()
-        case 'accounts.loginRespond':
-          answered.push(params!)
-          return {}
-        default:
-          throw new Error(`unexpected ${method}`)
-      }
-    }) as unknown as AccountsCall
-    // Account, then Sign in, then the provider; one sign-in method means no second pick. The
-    // browser step is answered with "Check status", and the prompt is typed as '123'.
-    const script = person(['Main', 'Sign in', 'Anthropic', 'Check status', '123', 'Back', 'Done'])
-    expect(await runAccountsMenu(script.ui, call, { accountId: 'a1', label: 'Main' })).toBeUndefined()
-    expect(answered).toEqual([{ loginId: 'L1', promptId: 'P1', value: '123' }])
-    expect(script.said.map((entry) => entry.message)).toContain('Signed in.')
-    expect(script.remaining()).toBe(0)
-  })
-})