@xingular/harness 0.1.7 → 1.1.1

package/src/terminal/tui/presentation.test.ts

@@ -1,79 +0,0 @@
-import type { Theme } from '@earendil-works/pi-coding-agent'
-import { colorToHex, stripTerminalSequences, visibleWidth, type TerminalColorMode } from '@earendil-works/pi-tui'
-import { describe, expect, it } from 'vitest'
-
-import { createHarnessLightTheme, createHarnessTheme } from './theme'
-import { gradientLogo, HarnessWelcome, PI_LOGO } from './welcome'
-
-function titanium(mode: TerminalColorMode = 'truecolor'): Theme {
-  return createHarnessTheme({ getColorMode: () => mode } as Theme)
-}
-
-describe('the Harness titanium presentation', () => {
-  it('uses the upstream titanium foreground and background colors with complete Pi fallbacks', () => {
-    const theme = titanium()
-    expect(theme.name).toBe('harness-titanium')
-    expect(theme.appearance).toBe('dark')
-    const expected = {
-      accent: '#00b4ff', border: '#2a3038', success: '#00ff88', error: '#ff4757',
-      customMessageLabel: '#d4c090', userMessageBg: '#0f1216', toolErrorBg: '#1a0f10',
-      thinkingMax: '#d4c090', scrollbarTrack: '#2a3038', scrollbarThumb: '#9ca3b0',
-      searchMatchBg: '#0082b3', searchMatchText: '#e8ecf4'
-    } as const
-    for (const [token, color] of Object.entries(expected)) {
-      expect(colorToHex(theme.colors[token as keyof typeof expected]), token).toBe(color)
-    }
-    expect(Object.keys(theme.colors)).toHaveLength(56)
-    expect(theme.getFgAnsi('text')).toBe('\x1b[39m')
-    expect(theme.getBgAnsi('userMessageBg')).toBe('\x1b[48;2;15;18;22m')
-  })
-
-  it('offers the shipped light palette with complete native component fallbacks', () => {
-    const theme = createHarnessLightTheme(titanium())
-    expect(theme.name).toBe('light')
-    expect(theme.appearance).toBe('light')
-    expect(Object.keys(theme.colors)).toHaveLength(56)
-    expect(colorToHex(theme.colors.accent)).toBe('#5a8080')
-    expect(colorToHex(theme.colors.selectedBg)).toBe('#d0d0e0')
-    expect(colorToHex(theme.colors.toolSuccessBg)).toBe('#e8f0e8')
-  })
-
-  it('keeps the current terminal color mode and uses the exact upstream logo ramps', () => {
-    const truecolor = gradientLogo(PI_LOGO, 'truecolor')
-    expect(truecolor[0]).toMatch(/^\x1b\[38;2;248;79;204m█/)
-    expect(truecolor[0]).toContain('\x1b[38;2;147;98;244m█\x1b[0m')
-    expect(truecolor.map(stripTerminalSequences)).toEqual(PI_LOGO)
-    const theme = titanium('256color')
-    expect(theme.getColorMode()).toBe('256color')
-    const indexed = gradientLogo(PI_LOGO, theme.getColorMode())
-    expect(indexed[0]).toMatch(/^\x1b\[38;5;206m█/)
-    expect(indexed[0]).toContain('\x1b[38;5;99m█\x1b[0m')
-    expect(indexed.join('')).not.toContain('[38;2;')
-  })
-
-  it('keeps every rendered row within the terminal across narrow widths and Unicode product names', () => {
-    for (const name of ['Xingular Harness', 'Harness 知識 🧠', 'A'.repeat(120)]) {
-      const welcome = new HarnessWelcome(titanium(), name)
-      for (let width = 0; width <= 160; width++) {
-        const lines = welcome.render(width)
-        for (const line of lines) expect(visibleWidth(line), `width ${width}, ${name}`).toBeLessThanOrEqual(width)
-        if (width < 14) expect(lines).toEqual([])
-      }
-    }
-  })
-
-  it('shows a centered five-row logo alone in narrow terminals and centers the full lockup when it fits', () => {
-    const welcome = new HarnessWelcome(titanium(), 'Xingular Harness', '0.1.6')
-    const narrow = welcome.render(30).map(stripTerminalSequences)
-    expect(narrow).toEqual(PI_LOGO.map((line) => ' '.repeat(9) + line))
-    const wide = welcome.render(100).map(stripTerminalSequences)
-    expect(wide[1]).toContain('Xingular Harness')
-    expect(wide[4]).toContain('v0.1.6')
-    expect(wide[0].indexOf('█')).toBe(34)
-    expect(wide.slice(6).join(' ')).toContain('/accounts')
-    expect(wide.slice(6).join(' ')).toContain('/plugins')
-    expect(wide.slice(6).join(' ')).toContain('/hub')
-    expect(wide.join('')).not.toContain('omp')
-    expect(welcome.render(49)).toHaveLength(5)
-  })
-})

package/src/terminal/tui/questions.test.ts

@@ -1,41 +0,0 @@
-import type { ExtensionUIContext } from '@earendil-works/pi-coding-agent'
-import { describe, expect, it, vi } from 'vitest'
-import { answerTerminalQuestion } from './questions'
-
-function fixture() {
-  const ui = { select: vi.fn(), input: vi.fn() }
-  return { ui, context: ui as unknown as ExtensionUIContext, signal: new AbortController().signal }
-}
-
-describe('terminal question answers', () => {
-  it('keeps action-like option labels distinct from dialog actions', async () => {
-    const { ui, context, signal } = fixture()
-    ui.select.mockResolvedValue('1. Write an answer — Actual choice')
-    expect(await answerTerminalQuestion(context, { requestId: 'q', question: 'Choose?', options: [{ label: 'Write an answer', description: 'Actual choice' }] }, signal)).toEqual({ selected: ['Write an answer'] })
-    expect(ui.input).not.toHaveBeenCalled()
-  })
-
-  it('returns to choices when text entry is cancelled and retains multiple selections', async () => {
-    const { ui, context, signal } = fixture()
-    ui.select.mockResolvedValueOnce('1. A').mockResolvedValueOnce('Write an answer').mockResolvedValueOnce('Submit choices')
-    ui.input.mockResolvedValue(undefined)
-    expect(await answerTerminalQuestion(context, { requestId: 'q', question: 'Choose?', options: [{ label: 'A' }], multiSelect: true }, signal)).toEqual({ selected: ['A'] })
-    expect(ui.select).toHaveBeenCalledTimes(3)
-    expect(ui.select.mock.calls[2][1]).toContain('1. ✓ A')
-  })
-
-  it('shows real batch progress and returns cancellation without inventing an answer', async () => {
-    const { ui, context, signal } = fixture()
-    ui.input.mockResolvedValue(undefined)
-    expect(await answerTerminalQuestion(context, { requestId: 'q', question: 'Why?', summary: 'Reason', batchId: 'batch', batchIndex: 2, batchCount: 3 }, signal)).toBeUndefined()
-    expect(ui.input).toHaveBeenCalledWith('2 of 3 · Reason: Why?', undefined, { signal })
-  })
-
-  it('honors text restrictions and ignores answers after expiry', async () => {
-    const { ui, context } = fixture()
-    const controller = new AbortController()
-    ui.select.mockImplementation(async () => { controller.abort(); return '1. A' })
-    expect(await answerTerminalQuestion(context, { requestId: 'q', options: [{ label: 'A' }], allowText: false }, controller.signal)).toBeUndefined()
-    expect(ui.select.mock.calls[0][1]).toEqual(['1. A'])
-  })
-})

package/src/terminal/tui/questions.ts

@@ -1,47 +0,0 @@
-import type { ExtensionUIContext } from '@earendil-works/pi-coding-agent'
-import type { QuestionAnswer } from '../../sessions/registry'
-
-export interface TerminalQuestion {
-  requestId: string
-  question?: string
-  summary?: string
-  options?: { label: string; description?: string }[]
-  multiSelect?: boolean
-  allowText?: boolean
-  batchId?: string
-  batchIndex?: number
-  batchCount?: number
-}
-
-/** Answers stay local until the complete group can be submitted to the registry. */
-export async function answerTerminalQuestion(ui: ExtensionUIContext, request: TerminalQuestion, signal: AbortSignal): Promise<QuestionAnswer | undefined> {
-  const choices = request.options ?? []
-  const selected: string[] = []
-  const progress = request.batchId ? `${request.batchIndex} of ${request.batchCount} · ` : ''
-  const title = `${progress}${request.summary ? request.summary + ': ' : ''}${request.question ?? 'Question'}`
-  if (!choices.length) {
-    if (request.allowText === false) return { selected }
-    const text = await ui.input(title, undefined, { signal })
-    return text === undefined || signal.aborted ? undefined : { selected, text }
-  }
-  while (!signal.aborted) {
-    const labels = choices.map((option, index) => `${index + 1}. ${selected.includes(option.label) ? '✓ ' : ''}${option.label}${option.description ? ' — ' + option.description : ''}`)
-    const menu = [...labels, ...(request.allowText !== false ? ['Write an answer'] : []), ...(request.multiSelect ? ['Submit choices'] : [])]
-    const choice = await ui.select(title, menu, { signal })
-    if (choice === undefined || signal.aborted) return undefined
-    if (choice === 'Submit choices') return { selected }
-    if (choice === 'Write an answer') {
-      const text = await ui.input(title, undefined, { signal })
-      if (signal.aborted) return undefined
-      if (text !== undefined) return { selected, text }
-      continue
-    }
-    const index = labels.indexOf(choice)
-    if (index < 0) throw new Error('Choose one of the displayed answers.')
-    const label = choices[index]!.label
-    if (selected.includes(label)) selected.splice(selected.indexOf(label), 1)
-    else selected.push(label)
-    if (!request.multiSelect) return { selected }
-  }
-  return undefined
-}

package/src/terminal/tui/runtime.socket.test.ts

@@ -1,104 +0,0 @@
-import type { ExtensionUIContext } from '@earendil-works/pi-coding-agent'
-import { mkdtempSync, mkdirSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, describe, expect, it, vi } from 'vitest'
-
-import { createHarness, type Harness } from '../../harness'
-import { memorySecretStore } from '../../accounts/secrets'
-import { connectionFromEnv, socketCall, terminalCall } from '../client'
-import { controlCall } from '../control'
-import { createTerminalRuntime, type TerminalRuntime } from './runtime'
-
-const opened: Array<{ harness: Harness; runtime?: TerminalRuntime; root: string }> = []
-afterEach(async () => {
-  for (const entry of opened.splice(0)) {
-    await entry.runtime?.dispose()
-    await entry.harness.close()
-    rmSync(entry.root, { recursive: true, force: true })
-  }
-  vi.restoreAllMocks()
-  vi.unstubAllEnvs()
-})
-
-async function setup() {
-  const root = mkdtempSync(join(tmpdir(), 'harness-sdk-socket-'))
-  const cwd = join(root, 'project')
-  mkdirSync(cwd)
-  const harness = createHarness({ dataRoot: join(root, 'data'), stateDir: join(root, 'state'), secrets: memorySecretStore(), resolver: async () => [], piProgram: () => '/not-spawned/pi', assets: { node: process.execPath, cli: join(root, 'cli.js'), piExtension: join(root, 'terminal-pi.js') } })
-  const entry: { harness: Harness; runtime?: TerminalRuntime; root: string } = { harness, root }
-  opened.push(entry)
-  await harness.ready
-  const account = harness.accounts.create('Offline test', 'apiKey').accounts[0]
-  const launch = await harness.terminals.prepare({ sessionId: 'offline-sdk', cwd, accountId: account.id, sessionFolder: join(root, 'history') })
-  for (const [name, value] of Object.entries(launch.env)) vi.stubEnv(name, value === null ? undefined : value)
-  vi.spyOn(process, 'cwd').mockReturnValue(cwd)
-  const ui = { select: vi.fn(async () => undefined), confirm: vi.fn(async () => false), notify: vi.fn(), getEditorText: () => '' } as unknown as ExtensionUIContext
-  const runtime = await createTerminalRuntime(launch.args, { ui, notify: vi.fn(), changed: vi.fn(), shutdown: vi.fn() })
-  entry.runtime = runtime
-  return { harness, runtime, ui, account }
-}
-
-describe('a native SDK runtime on the actual Harness terminal socket', () => {
-  it('keeps the same account, command control and readiness after new/reload with no provider request', async () => {
-    const { harness, runtime, ui } = await setup()
-    expect(harness.terminals.state('offline-sdk')).toEqual({ ready: true, dirty: false, active: false })
-    expect(runtime.session.extensionRunner.getExtensionPaths()).toEqual(['<inline:harness-terminal-bridge>'])
-    expect(runtime.services.agentDir).toContain(harness.accounts.dir)
-    for (const command of ['accounts', 'plugins', 'hub']) expect(runtime.session.extensionRunner.getCommand(command)).toBeDefined()
-    await runtime.session.prompt('/accounts')
-    expect(ui.select).toHaveBeenCalled()
-    await runtime.newSession()
-    await runtime.reload()
-    await runtime.session.prompt('/accounts')
-    expect(ui.select).toHaveBeenCalledTimes(2)
-    expect(harness.terminals.state('offline-sdk')).toEqual({ ready: true, dirty: false, active: false })
-    await expect(controlCall('terminal.resources')).resolves.toEqual({})
-    await expect(socketCall(connectionFromEnv(), 'control.claim')).rejects.toThrow('already claimed')
-    const blocked = await runtime.session.extensionRunner.emitToolCall({ type: 'tool_call', toolName: 'bash', toolCallId: 'no-active-run', input: { command: 'echo must-not-execute' } })
-    expect(blocked?.block).toBe(true)
-    await runtime.dispose()
-    expect(harness.terminals.state('offline-sdk').ready).toBe(false)
-  })
-
-  it('submits grouped terminal answers atomically through the protected real registry', async () => {
-    const { harness, runtime } = await setup()
-    const events: Array<{ type: string; payload: unknown }> = []
-    harness.runs.listen(event => { events.push(event) })
-    await terminalCall('begin', { text: 'Grouped terminal fixture' })
-    const tool = runtime.session.getToolDefinition('ask_user')!
-    const result = tool.execute('batch-tool', { questions: [
-      { summary: 'First choice', question: 'Which?', options: [{ label: 'A', description: 'First option' }] },
-      { summary: 'Second answer', question: 'Why?' }
-    ] }, undefined, undefined, runtime.session.extensionRunner.createToolContext('batch-tool', undefined))
-    let questions: Array<{ requestId: string; batchId: string }> = []
-    await vi.waitFor(async () => {
-      questions = await runtime.pending() as typeof questions
-      expect(questions).toHaveLength(2)
-    })
-    expect(questions[0].batchId).toBe(questions[1].batchId)
-    const answers = [{ questionId: questions[0].requestId, answer: { selected: ['A'] } }, { questionId: questions[1].requestId, answer: { selected: [], text: 'Because' } }]
-    await expect(socketCall(connectionFromEnv(), 'terminal.answers', { batchId: questions[0].batchId, answers })).rejects.toThrow('Only a person')
-    await expect(controlCall('terminal.answers', { batchId: questions[0].batchId, answers: answers.slice(0, 1) })).rejects.toThrow('batch')
-    expect(events.filter(event => event.type === 'question.answered')).toHaveLength(0)
-    await runtime.answerBatch(questions[0].batchId, answers)
-    await expect(result).resolves.toMatchObject({ content: [{ text: 'First choice: The user chose: A.\nSecond answer: The user answered: Because' }] })
-    expect(events.filter(event => event.type === 'question.answered')).toHaveLength(2)
-    await expect(controlCall('terminal.pending')).resolves.toEqual({ requests: [] })
-  })
-
-  it('settles an actual socket-backed pending question before disposing the native session', async () => {
-    const { harness, runtime } = await setup()
-    await terminalCall('begin', { text: 'Offline question bridge fixture' })
-    let questionReached!: () => void
-    const reached = new Promise<void>((resolve) => { questionReached = resolve })
-    harness.runs.listen((event) => { if (event.type === 'question.requested') questionReached() })
-    const tool = runtime.session.getToolDefinition('ask_user_question')!
-    const answer = tool.execute('offline-question', { question: 'Continue?', options: [] }, undefined, undefined, runtime.session.extensionRunner.createToolContext('offline-question', undefined))
-    await reached
-    await expect(controlCall<{ requests: unknown[] }>('terminal.pending')).resolves.toMatchObject({ requests: [expect.anything()] })
-    await runtime.dispose()
-    await expect(answer).resolves.toMatchObject({ content: [{ type: 'text', text: '{"selected":[]}' }] })
-    expect(harness.terminals.state('offline-sdk')).toEqual({ ready: false, dirty: false, active: false })
-  })
-})

package/src/terminal/tui/runtime.test.ts

@@ -1,215 +0,0 @@
-import { mkdtempSync, mkdirSync, readFileSync, realpathSync, readdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import type { ExtensionAPI, ExtensionUIContext } from '@earendil-works/pi-coding-agent'
-
-const transport = vi.hoisted(() => ({ claim: vi.fn(async () => 'private-control'), call: vi.fn(async (_call: string) => ({})) }))
-vi.mock('../control', () => ({ claimTerminalControl: transport.claim, controlCall: transport.call }))
-vi.mock('../piExtension', () => ({ default: (pi: ExtensionAPI) => {
-  pi.on('session_start', (_event, ctx) => { pi.appendEntry('bridge-start', { mode: ctx.mode }) })
-} }))
-
-import { assertTerminalSessionScope, createTerminalRuntime, parseTerminalArguments, type TerminalRuntime } from './runtime'
-import { assertPiAdapterVersion, loadPiAdapter, withBuiltInRenderers } from './piAdapter'
-
-const folders: string[] = []
-const runtimes: TerminalRuntime[] = []
-afterEach(async () => {
-  for (const runtime of runtimes.splice(0)) await runtime.dispose()
-  vi.restoreAllMocks()
-  vi.unstubAllEnvs()
-  transport.call.mockReset().mockResolvedValue({})
-  transport.claim.mockClear()
-  for (const folder of folders.splice(0)) rmSync(folder, { recursive: true, force: true })
-})
-
-function fixture() {
-  const root = mkdtempSync(join(tmpdir(), 'harness-terminal-runtime-'))
-  folders.push(root)
-  const cwd = join(root, 'project')
-  const account = join(root, 'account')
-  const history = join(root, 'history')
-  mkdirSync(cwd)
-  mkdirSync(account)
-  mkdirSync(history)
-  vi.spyOn(process, 'cwd').mockReturnValue(cwd)
-  vi.stubEnv('PI_CODING_AGENT_DIR', account)
-  const plugin = join(root, 'fixture.mjs')
-  writeFileSync(plugin, `export default function (pi) {
-    pi.on('session_start', (_event, ctx) => pi.appendEntry('fixture-start', { mode: ctx.mode }))
-    pi.registerCommand('marker', { description: 'A local fixture command', handler: async (args) => { pi.appendEntry('marker', { text: args }) } })
-  }`)
-  const args = ['--no-extensions', '--no-skills', '--no-prompt-templates', '--no-themes', '--extension', plugin, '--extension', join(root, 'terminal-pi.js'), '--session-dir', history, '--append-system-prompt', 'Fixed Harness context.']
-  const changed = vi.fn()
-  const ui = { getEditorText: () => '', select: vi.fn(async () => undefined), notify: vi.fn() } as unknown as ExtensionUIContext
-  return { root, cwd, account, history, plugin, args, host: { ui, changed, shutdown: vi.fn(), notify: vi.fn() } }
-}
-
-async function openFixture() {
-  const f = fixture()
-  const runtime = await createTerminalRuntime(f.args, f.host)
-  runtimes.push(runtime)
-  return { ...f, runtime }
-}
-
-describe('the persistent terminal SDK adapter', () => {
-  it('parses only the prepared resource flags without discovering extra resources', () => {
-    const parsed = parseTerminalArguments(['--no-extensions', '--extension', 'builtin:mcp', '--extension', '/bridge.js', '--skill', '/skill', '--prompt-template', '/prompt', '--theme', '/theme', '--session-dir', '/history', '--session', '/history/old.jsonl', '--model', 'provider/model', '--append-system-prompt', 'context'])
-    expect(parsed).toEqual({ appendSystemPrompt: ['context'], extensions: ['builtin:mcp', '/bridge.js'], skills: ['/skill'], prompts: ['/prompt'], themes: ['/theme'], sessionDir: '/history', session: '/history/old.jsonl', model: 'provider/model' })
-    expect(() => parseTerminalArguments(['--serve'])).toThrow('Unsupported')
-    expect(() => parseTerminalArguments(['--session-dir'])).toThrow('needs a value')
-    expect(() => parseTerminalArguments(['--session-dir', '/history'])).toThrow('bridge extension')
-  })
-
-  it('loads only explicit plugins and keeps events and commands alive across new, resume, fork and reload', async () => {
-    const { runtime, args, root, cwd } = await openFixture()
-    const first = runtime.session
-    const firstFile = first.sessionFile!
-    expect(first.systemPrompt).toContain('Fixed Harness context.')
-    expect(first.extensionRunner.getExtensionPaths()).toEqual([args[5], '<inline:harness-terminal-bridge>'])
-    expect(first.sessionManager.getEntries().filter((entry) => entry.type === 'custom').map((entry) => entry.data)).toEqual([{ mode: 'tui' }, { mode: 'tui' }])
-    const events: string[] = []
-    runtime.subscribe((event) => events.push(event.type))
-    const replacements: string[] = []
-    runtime.onSessionChange((session) => { replacements.push(session.sessionId) })
-    const before = vi.fn()
-    runtime.onBeforeSessionChange(before)
-    await runtime.session.prompt('/marker first')
-    // Native Pi keeps custom-entry-only sessions in memory until an assistant response. This
-    // fixture persists its actual native entries without making a provider request.
-    writeFileSync(firstFile, [first.sessionManager.getHeader(), ...first.sessionManager.getEntries()].map((entry) => JSON.stringify(entry)).join('\n') + '\n')
-    expect(events).toContain('entry_appended')
-    await runtime.newSession()
-    expect(runtime.session).not.toBe(first)
-    await runtime.session.prompt('/marker second')
-    await runtime.switchSession(firstFile)
-    expect(runtime.session.sessionFile).toBe(firstFile)
-    const marker = runtime.session.sessionManager.getEntries().find((entry) => entry.type === 'custom' && entry.customType === 'marker')!
-    await runtime.fork(marker.id, { position: 'at' })
-    expect(runtime.session.sessionFile).not.toBe(firstFile)
-    await runtime.reload()
-    await runtime.session.prompt('/marker reloaded')
-    expect(runtime.session.sessionManager.getEntries().some((entry) => entry.type === 'custom' && entry.customType === 'marker' && (entry.data as { text: string }).text === 'reloaded')).toBe(true)
-    expect(replacements).toHaveLength(4)
-    expect(before).toHaveBeenCalledTimes(4)
-    expect(transport.claim).toHaveBeenCalledTimes(1)
-    expect(transport.call.mock.calls.length).toBeGreaterThanOrEqual(6)
-    expect(transport.call.mock.calls.every(([call]) => ['terminal.resources', 'terminal.interrupt', 'accounts.session'].includes(call))).toBe(true)
-    expect(readFileSync(firstFile, 'utf8')).toContain(cwd)
-    expect(readdirSync(root)).not.toContain('.pi')
-  })
-
-  it('ignores retained plugin UI callbacks after new, reload and disposal', async () => {
-    const { runtime, host } = await openFixture()
-    const first = runtime.session.extensionRunner.createContext().ui
-    const retainedNotify = first.notify
-    first.notify('current')
-    expect(host.ui.notify).toHaveBeenCalledWith('current')
-    await runtime.newSession()
-    retainedNotify('late from previous session')
-    expect(host.ui.notify).toHaveBeenCalledTimes(1)
-    expect(await first.select('Stale selector', ['One'])).toBeUndefined()
-    const second = runtime.session.extensionRunner.createContext().ui
-    second.notify('replacement')
-    expect(host.ui.notify).toHaveBeenCalledTimes(2)
-    await runtime.reload()
-    second.notify('late from old resources')
-    expect(host.ui.notify).toHaveBeenCalledTimes(2)
-    const reloaded = runtime.session.extensionRunner.createContext().ui
-    reloaded.notify('reloaded')
-    expect(host.ui.notify).toHaveBeenCalledTimes(3)
-    await runtime.dispose()
-    reloaded.notify('late after exit')
-    expect(host.ui.notify).toHaveBeenCalledTimes(3)
-  })
-
-  it('returns immutable presentation state and routes submissions through the persistent session', async () => {
-    const { runtime } = await openFixture()
-    const first = runtime.snapshot()
-    expect(Object.isFrozen(first)).toBe(true)
-    expect(Object.isFrozen(first.queue.steering)).toBe(true)
-    expect(Object.isFrozen(first.context)).toBe(true)
-    expect(first.account).toBeNull()
-    await runtime.submit('   /marker from-runtime')
-    runtime.session.setSessionName('Updated title')
-    expect(first.name).toBeUndefined()
-    expect(runtime.snapshot().name).toBe('Updated title')
-    expect(runtime.session.sessionManager.getEntries().some(entry => entry.type === 'custom' && entry.customType === 'marker' && (entry.data as { text: string }).text === 'from-runtime')).toBe(true)
-    await runtime.dispose()
-    await expect(runtime.submit('late')).rejects.toThrow('closed')
-  })
-
-  it('refuses changed resource trust before invalidating the existing session or loading new code', async () => {
-    const { runtime, plugin, root } = await openFixture()
-    const existing = runtime.session
-    const marker = join(root, 'untrusted-code-ran')
-    writeFileSync(plugin, `import { writeFileSync } from 'node:fs'; writeFileSync(${JSON.stringify(marker)}, 'yes'); export default function () {}`)
-    transport.call.mockRejectedValue(new Error('Plugin code changed; review and restart.'))
-    await expect(runtime.reload()).rejects.toThrow('Plugin code changed')
-    await expect(runtime.newSession()).rejects.toThrow('Plugin code changed')
-    expect(runtime.session).toBe(existing)
-    await runtime.session.prompt('/marker still-active')
-    expect(readdirSync(root)).not.toContain('untrusted-code-ran')
-    expect(runtime.session.extensionRunner.getCommand('marker')).toBeDefined()
-    await expect(runtime.session.resourceLoader.reload()).rejects.toThrow('Plugin code changed')
-    expect(readdirSync(root)).not.toContain('untrusted-code-ran')
-  })
-
-  it('rejects cross-project resume/import before copying files or replacing the pinned session', async () => {
-    const { runtime, root, cwd, history } = await openFixture()
-    const other = join(root, 'other-project')
-    mkdirSync(other)
-    const imported = join(history, 'other.jsonl')
-    writeFileSync(imported, JSON.stringify({ type: 'session', version: 3, id: 'foreign', cwd: other, timestamp: new Date().toISOString() }) + '\n')
-    const current = runtime.session
-    const files = readdirSync(history)
-    await expect(runtime.switchSession(imported)).rejects.toThrow('another working folder')
-    await expect(runtime.importFromJsonl(imported, cwd)).rejects.toThrow('another working folder')
-    expect(runtime.session).toBe(current)
-    expect(readdirSync(history)).toEqual(files)
-    expect(() => assertTerminalSessionScope(imported, cwd, other)).toThrow('own working folder')
-  })
-
-  it('rejects symlink escapes and same-project history outside the prepared history folder', async () => {
-    const { runtime, root, cwd, history, args, host } = await openFixture()
-    const external = join(root, 'external.jsonl')
-    writeFileSync(external, JSON.stringify({ type: 'session', version: 3, id: 'external', cwd, timestamp: new Date().toISOString() }) + '\n')
-    const symlink = join(history, 'escaped.jsonl')
-    symlinkSync(external, symlink)
-    const original = runtime.session
-    await expect(runtime.switchSession(external)).rejects.toThrow('terminal history folder')
-    await expect(runtime.switchSession(symlink)).rejects.toThrow('terminal history folder')
-    await expect(createTerminalRuntime([...args, '--session', symlink], host)).rejects.toThrow('terminal history folder')
-    expect(runtime.session).toBe(original)
-    await runtime.importFromJsonl(external)
-    expect(runtime.session.sessionManager.getHeader()?.id).toBe('external')
-    expect(runtime.session.sessionFile).toBe(join(realpathSync(history), 'external.jsonl'))
-  })
-
-  it('requires the prepared isolated account and refuses malformed session headers', async () => {
-    const f = fixture()
-    vi.stubEnv('PI_CODING_AGENT_DIR', '')
-    await expect(createTerminalRuntime(f.args, f.host)).rejects.toThrow('isolated account')
-    const invalid = join(f.root, 'invalid.jsonl')
-    writeFileSync(invalid, 'not a session\n')
-    expect(() => assertTerminalSessionScope(invalid, f.cwd)).toThrow('readable native session header')
-    writeFileSync(invalid, JSON.stringify({ type: 'session', cwd: 'relative' }))
-    expect(() => assertTerminalSessionScope(invalid, f.cwd)).toThrow('absolute working folder')
-  })
-
-  it('loads the pinned rich renderers without opening a model or reading the clipboard', async () => {
-    expect(() => assertPiAdapterVersion('1.3.0')).toThrow('requires Pi 1.2.0')
-    const adapter = await loadPiAdapter()
-    expect(adapter.builtins.map((item) => typeof item === 'function' ? '' : item.name)).toEqual(['llama.cpp', 'codemode', 'tool-search', 'mcp'])
-    for (const name of ['read', 'bash', 'edit', 'write']) {
-      const renderers = withBuiltInRenderers(name, undefined)
-      expect(renderers?.renderCall).toBeTypeOf('function')
-      expect(renderers?.renderResult).toBeTypeOf('function')
-    }
-    const custom = { renderCall: vi.fn() }
-    expect(withBuiltInRenderers('read', custom)?.renderCall).toBe(custom.renderCall)
-    expect(adapter.readClipboardText).toBeTypeOf('function')
-    expect(adapter.readClipboardImage).toBeTypeOf('function')
-  })
-})