@xingular/harness 0.1.6 → 2.0.0

package/src/terminal/tui/piAdapter.ts

@@ -0,0 +1,62 @@
+// Pi 1.2.0 omits CLI builtins, rich builtin renderers, clipboard reads and the global theme setter
+// from its public exports. Keep those version-sensitive presentation hooks here; session/runtime
+// work uses public APIs. Clipboard helpers are only called for an explicit user paste.
+import { getPackageDir, VERSION, type InlineExtension, type Theme, type ToolRenderers } from '@earendil-works/pi-coding-agent'
+import { join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+export interface PiAdapter {
+  builtins: InlineExtension[]
+  setTheme(theme: Theme): void
+  withBuiltInRenderers(toolName: string, definition: ToolRenderers | undefined): ToolRenderers | undefined
+  readClipboardText(): Promise<string | null>
+  readClipboardFilePaths(): Promise<string[] | null>
+  readClipboardImage(): Promise<{ bytes: Uint8Array; mimeType: string } | null>
+  extensionForImageMimeType(mimeType: string): string | null
+}
+
+let adapter: PiAdapter | undefined
+let loading: Promise<PiAdapter> | undefined
+
+export function assertPiAdapterVersion(version: string): void {
+  if (version !== '1.2.0') throw new Error(`The Harness terminal adapter requires Pi 1.2.0; found ${version}. Install the Harness package's pinned dependencies.`)
+}
+
+export function loadPiAdapter(): Promise<PiAdapter> {
+  loading ??= (async () => {
+    assertPiAdapterVersion(VERSION)
+    const root = getPackageDir()
+    const [extensions, theme, renderers, clipboard, images] = await Promise.all([
+      import(pathToFileURL(join(root, 'dist/extensions/index.js')).href),
+      import(pathToFileURL(join(root, 'dist/modes/interactive/theme/theme.js')).href),
+      import(pathToFileURL(join(root, 'dist/core/tools/renderers/index.js')).href),
+      import(pathToFileURL(join(root, 'dist/utils/clipboard.js')).href),
+      import(pathToFileURL(join(root, 'dist/utils/clipboard-image.js')).href)
+    ])
+    if (!Array.isArray(extensions.builtInExtensions) || typeof theme.setThemeInstance !== 'function' || typeof renderers.withBuiltInRenderers !== 'function' || typeof clipboard.readClipboardText !== 'function' || typeof clipboard.readClipboardFilePaths !== 'function' || typeof images.readClipboardImage !== 'function' || typeof images.extensionForImageMimeType !== 'function') {
+      throw new Error('The pinned Pi terminal adapter no longer exposes its required builtin or theme hooks.')
+    }
+    adapter = {
+      builtins: extensions.builtInExtensions as InlineExtension[],
+      setTheme: theme.setThemeInstance,
+      withBuiltInRenderers: renderers.withBuiltInRenderers,
+      readClipboardText: clipboard.readClipboardText,
+      readClipboardFilePaths: clipboard.readClipboardFilePaths,
+      readClipboardImage: images.readClipboardImage,
+      extensionForImageMimeType: images.extensionForImageMimeType
+    }
+    return adapter
+  })()
+  return loading
+}
+
+/** Initialize once with loadPiAdapter() before rendering native rich tool components. */
+export function setPiTheme(theme: Theme): void {
+  if (!adapter) throw new Error('Initialize the Pi terminal adapter before setting its theme.')
+  adapter.setTheme(theme)
+}
+
+export function withBuiltInRenderers(toolName: string, definition: ToolRenderers | undefined): ToolRenderers | undefined {
+  if (!adapter) throw new Error('Initialize the Pi terminal adapter before resolving builtin renderers.')
+  return adapter.withBuiltInRenderers(toolName, definition)
+}

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

@@ -0,0 +1,10 @@
+import { describe, expect, it } from 'vitest'
+
+import { planModeTools } from './planMode'
+
+describe('plan mode tools', () => {
+  it('keeps read-only inspection, questions and recall, and withdraws changes, commands and delegation', () => {
+    const normal = ['read', 'bash', 'edit', 'write', 'grep', 'find', 'ls', 'ask_user', 'ask_user_question', 'wiki_search', 'memory_append', 'spawn_subagent', 'app_tool', 'history_read']
+    expect(planModeTools(normal)).toEqual(['read', 'grep', 'find', 'ls', 'ask_user', 'ask_user_question', 'wiki_search', 'history_read'])
+  })
+})

package/src/terminal/tui/planMode.ts

@@ -0,0 +1,12 @@
+import { ASK_USER } from '../../tools/askUser'
+
+// Read-only inspection, questions and recall. Everything else is withdrawn in plan mode: file changes, commands,
+// memory writes, delegation and connected apps, since none of them can be judged read-only from their names.
+const READ_ONLY_TOOLS = new Set([
+  'read', 'grep', 'find', 'ls', ASK_USER, 'ask_user_question',
+  'history_search', 'history_read', 'wiki_entrypoint', 'wiki_search', 'wiki_read', 'wiki_list', 'memory_facts'
+])
+
+export function planModeTools(normal: readonly string[]): string[] {
+  return normal.filter(name => READ_ONLY_TOOLS.has(name))
+}

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,178 @@
+import type { ExtensionUIContext } from '@earendil-works/pi-coding-agent'
+import { mkdtempSync, mkdirSync, readFileSync, 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 type { TerminalPrepareInput } from '../terminals'
+import { controlCall } from '../control'
+import { readAllRuns } from '../../sessions/runIndex'
+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(input: Partial<TerminalPrepareInput> = {}) {
+  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'), ...input })
+  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('reads and changes shared terminal permissions only through the claimed private control key', async () => {
+    const { runtime } = await setup()
+    await expect(socketCall(connectionFromEnv(), 'terminal.permissions.get')).rejects.toThrow('Only a person')
+    expect(await runtime.permissions()).toEqual({ full: false, globalTools: [] })
+    await runtime.setGlobalTool('bash', true)
+    await runtime.setFullPermission(true)
+    expect(await runtime.permissions()).toEqual({ full: true, globalTools: ['bash'] })
+    await runtime.setGlobalTool('bash', false)
+    await runtime.setFullPermission(false)
+    expect(await runtime.permissions()).toEqual({ full: false, globalTools: [] })
+  })
+
+  it('runs asynchronous children through the protected bridge and joins their results before settling', async () => {
+    const { harness, runtime } = await setup()
+    const ai = await import('@earendil-works/pi-ai')
+    const faux = ai.fauxProvider()
+    runtime.services.modelRuntime.registerNativeProvider(faux.provider)
+    harness.accounts.runtime = async () => runtime.services.modelRuntime
+    await runtime.session.setModel(faux.getModel())
+    const route = (context: { messages: Array<{ role: string; content: unknown }> }) => {
+      const users = context.messages.filter(message => message.role === 'user').map(message => typeof message.content === 'string' ? message.content : (message.content as Array<{ text?: string }>).map(part => part.text ?? '').join(''))
+      if (users.includes('terminal-native-child')) return ai.fauxAssistantMessage('TERMINAL_CHILD_EVIDENCE')
+      if (JSON.stringify(context.messages).includes('TERMINAL_CHILD_EVIDENCE')) return ai.fauxAssistantMessage('Final with TERMINAL_CHILD_EVIDENCE')
+      if (!context.messages.some(message => message.role === 'toolResult')) return ai.fauxAssistantMessage([ai.fauxToolCall('spawn_subagent', { brief: 'terminal-native-child' })], { stopReason: 'toolUse' })
+      return ai.fauxAssistantMessage('Draft before joining')
+    }
+    faux.setResponses(Array(8).fill(route) as never)
+    await expect(socketCall(connectionFromEnv(), 'terminal.subagents.tools')).rejects.toThrow('Only a person')
+    await runtime.session.prompt('Terminal parent')
+    const runs = readAllRuns(harness.env.root)
+    const parent = runs.find(run => run.sessionId === 'offline-sdk')!
+    const child = runs.find(run => run.relation === 'subagent')!
+    expect(parent.status).toBe('completed')
+    expect(child).toMatchObject({ parentRunId: parent.id, accountId: parent.accountId, status: 'completed' })
+    expect(harness.runs.activeRunIds()).toEqual([])
+    const entries = readFileSync(runtime.session.sessionFile!, 'utf8').trim().split('\n').map(line => JSON.parse(line))
+    const receipts = entries.filter(entry => entry.customType === 'xingular-subagent-results')
+    expect(receipts).toHaveLength(1)
+    expect(receipts[0].content).toContain('TERMINAL_CHILD_EVIDENCE')
+    expect(harness.terminals.state('offline-sdk').active).toBe(false)
+  })
+
+  it('routes a child approval to its original run through the terminal decision controls', async () => {
+    const { harness, runtime } = await setup()
+    await terminalCall('begin', { text: 'Parent fixture' })
+    await controlCall('terminal.subagents.register', { tools: ['read', 'bash', 'spawn_subagent', 'wait_subagents'], history: { owners: [], receipts: [] } })
+    const parentId = harness.runs.activeForSession('offline-sdk')!.runId
+    const { loadRun, saveRun } = await import('../../sessions/runStore')
+    const parent = loadRun(harness.env.root, parentId)
+    saveRun(harness.env.root, { ...parent, id: 'approval-child', sessionId: 'opaque-child', parentRunId: parentId, relation: 'subagent', status: 'queued', endedAt: null })
+    const active = harness.runs.start('opaque-child', 'approval-child')
+    const answer = active.requestApproval({ target: 'bash', action: 'fixture', rememberable: false })
+    let pending: Awaited<ReturnType<typeof runtime.pending>> = []
+    await vi.waitFor(async () => { pending = await runtime.pending(); expect(pending).toHaveLength(1) })
+    await runtime.approve(pending[0].requestId, 'denied')
+    await expect(answer).resolves.toBe('denied')
+    expect(await runtime.pending()).toEqual([])
+    active.finish('interrupted')
+  })
+
+  it('offers native tools without connected apps and preserves a read-only child ceiling', async () => {
+    const { harness, runtime } = await setup({ connections: false, readOnly: true })
+    expect(runtime.session.getToolDefinition('spawn_subagent')).toBeDefined()
+    await terminalCall('begin', { text: 'Read-only parent' })
+    await controlCall('terminal.subagents.register', { tools: ['read', 'write', 'bash', 'spawn_subagent', 'wait_subagents'], history: { owners: [], receipts: [] } })
+    const parentRunId = harness.runs.activeForSession('offline-sdk')!.runId
+    await expect(harness.subagents.spawn({ parentRunId, brief: 'Cannot widen', tools: ['write'] })).rejects.toThrow('cannot have tools')
+    const { loadRun } = await import('../../capabilities/runSnapshot')
+    expect(loadRun(harness.env.root, parentRunId)?.tools).toEqual(['read', 'spawn_subagent', 'wait_subagents'])
+    await runtime.interrupt()
+  })
+
+  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 })
+  })
+})