@xingular/harness 0.1.5 → 0.1.7

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

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,215 @@
+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')
+  })
+})