@xingular/harness 0.1.6 → 2.0.0

package/src/server/server.test.ts

@@ -59,6 +59,23 @@ function host(hostCalls: Record<string, (params: any) => unknown> = {}) {
 const idle = (): PiSessionLike => ({ sessionId: 'native-1', subscribe: () => () => undefined, prompt: async () => undefined, sendCustomMessage: async () => undefined, abort: async () => undefined, dispose: () => undefined })
 
 describe('the harness served to a host', () => {
+  it('starts native subagents over RPC using the live parent launch', async () => {
+    const { transport, request } = host()
+    const harness = createHarness({
+      dataRoot: rootWithProject(), stateDir: mkdtempSync(join(tmpdir(), 'hs-')), secrets: memorySecretStore(),
+      sessionFactory: async ({ params }) => ({ ...idle(), ...(params.runId === 'rpc-parent' ? { prompt: async () => new Promise<void>(() => undefined) } : {}) })
+    })
+    open.push(harness)
+    serve(harness, transport)
+    harness.accounts.create('Main', 'apiKey')
+    await request('sessions.run', { run: { id: 'rpc-parent', sessionId: 'opaque-session' }, cwd: harness.env.root, sessionDir: join(harness.env.root, 'sessions'), text: 'Parent', caller: { agentId: 'caller' }, tools: { allow: ['read'] }, subagents: {} })
+    const child = await request('subagents.spawn', { parentRunId: 'rpc-parent', brief: 'Review', tools: ['read'] })
+    expect(await request('subagents.wait', { parentRunId: 'rpc-parent', runIds: [child.runId] })).toMatchObject([{ runId: child.runId, status: 'completed' }])
+    const { loadRun } = await import('../sessions/runStore')
+    expect(loadRun(harness.env.root, child.runId)).toMatchObject({ parentRunId: 'rpc-parent', relation: 'subagent', agentId: 'caller', status: 'completed' })
+    await request('runs.interrupt', { runId: 'rpc-parent' })
+  })
+
   it('answers by method name, reports failures with their code, and forwards events and notices', async () => {
     const { transport, request, events, notices } = host()
     const harness = createHarness({ dataRoot: rootWithProject(), stateDir: mkdtempSync(join(tmpdir(), 'hs-')), secrets: memorySecretStore(), sessionFactory: async () => idle() })
@@ -67,7 +84,9 @@ describe('the harness served to a host', () => {
 
     const status = await request('harness.status')
     expect(status).toMatchObject({ dataRoot: harness.env.root, productName: 'Xingular Harness', activeRuns: [] })
-    expect(await request<string[]>('harness.methods')).toEqual(expect.arrayContaining(['accounts.list', 'sessions.run', 'wiki.pages', 'terminal.prepare', 'skills.list', 'skills.import', 'connections.list', 'harness.shutdown']))
+    expect(await request<string[]>('harness.methods')).toEqual(expect.arrayContaining(['accounts.list', 'sessions.run', 'sessions.spawnSubagent', 'subagents.spawn', 'subagents.wait', 'subagents.results', 'wiki.pages', 'terminal.prepare', 'skills.list', 'skills.import', 'connections.list', 'harness.shutdown']))
+
+    await expect(request('sessions.spawnSubagent', { parentRunId: 'missing', brief: 'Review' })).rejects.toMatchObject({ code: 'run_not_active' })
 
     const overview = await request('accounts.create', { label: 'Main', authKind: 'apiKey' })
     expect(overview.accounts).toHaveLength(1)

package/src/sessions/approvals.test.ts

@@ -0,0 +1,49 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+
+import { Bus } from '../core/bus'
+import { Approvals, grant } from './approvals'
+
+const folders: string[] = []
+afterEach(() => { for (const folder of folders.splice(0)) rmSync(folder, { recursive: true, force: true }) })
+
+function state() {
+  const folder = mkdtempSync(join(tmpdir(), 'harness-approvals-'))
+  folders.push(folder)
+  const bus = new Bus()
+  return { folder, approvals: new Approvals(folder, bus) }
+}
+
+describe('standing approval policy', () => {
+  it('loads old files with no global tool grants', () => {
+    const { folder, approvals } = state()
+    writeFileSync(join(folder, 'approvals.json'), JSON.stringify({ auto: { pi: true }, remembered: { old: ['write'] } }))
+
+    expect(approvals.read()).toEqual({ auto: { pi: true }, globalTools: {}, remembered: { old: ['write'] } })
+  })
+
+  it('persists a profile-wide tool grant, while read-only and other profiles stay isolated', () => {
+    const { folder, approvals } = state()
+    approvals.allowTool('pi', 'bash')
+    const policy = approvals.read()
+
+    expect(policy.globalTools).toEqual({ pi: ['bash'] })
+    expect(grant(policy, 'pi', 'terminal-one', 'bash')).toBe('remembered')
+    expect(grant(policy, 'pi', 'terminal-two', 'bash')).toBe('remembered')
+    expect(grant(policy, 'chat', 'terminal-two', 'bash')).toBeNull()
+    expect(grant(policy, 'pi', 'terminal-two', 'bash', { readOnly: true })).toBeNull()
+    expect(JSON.parse(readFileSync(join(folder, 'approvals.json'), 'utf8'))).toMatchObject({ globalTools: { pi: ['bash'] } })
+  })
+
+  it('revokes a global tool grant without changing the full switch or session grants', () => {
+    const { approvals } = state()
+    approvals.setAuto('pi', true)
+    approvals.remember('one-session', 'write')
+    approvals.allowTool('pi', 'bash')
+
+    expect(approvals.revokeTool('pi', 'bash')).toEqual({ auto: { pi: true }, globalTools: {}, remembered: { 'one-session': ['write'] } })
+    expect(approvals.read().globalTools).toEqual({})
+  })
+})

package/src/sessions/approvals.ts

@@ -1,5 +1,5 @@
-// What the user has chosen to stop being asked about: an "always approve" switch per kind of
-// session and, per session, the tools they answered "Always allow" for.
+// What the user has chosen to stop being asked about: an "always approve" switch, tools allowed
+// across a harness state directory, and tools remembered for one session.
 import { chmodSync } from 'node:fs'
 import { join } from 'node:path'
 
@@ -14,6 +14,8 @@ export const APPROVAL_KEYS = ['chat', 'pi'] as const
 export interface ApprovalPolicy {
   /** Switch key → every approval is granted without asking. */
   auto: Record<string, boolean>
+  /** Approval key → tools allowed across sessions that share this local state directory. */
+  globalTools: Record<string, string[]>
   /** Session id → approval targets always allowed there. */
   remembered: Record<string, string[]>
 }
@@ -34,13 +36,14 @@ export interface ApprovalFacts {
 /** Why the standing choices grant this request, if they do. */
 export function decide(policy: ApprovalPolicy, key: string, sessionId: string, target: string): AutomaticReason | null {
   if (policy.auto[key]) return 'always'
+  if (policy.globalTools[key]?.includes(target)) return 'remembered'
   return policy.remembered[sessionId]?.includes(target) ? 'remembered' : null
 }
 
 export function grant(policy: ApprovalPolicy, key: string, sessionId: string, target: string, facts: ApprovalFacts = {}): AutomaticReason | null {
   if (facts.unattended) return null
   // "Always approve" must not let a read-only session approve its way out of read-only mode.
-  return decide(facts.readOnly ? { auto: {}, remembered: policy.remembered } : policy, key, sessionId, target)
+  return decide(facts.readOnly ? { auto: {}, globalTools: {}, remembered: policy.remembered } : policy, key, sessionId, target)
 }
 
 /** A conversation's runs share one switch whatever model they use; other runs follow their own. */
@@ -55,7 +58,7 @@ export class Approvals {
 
   read(): ApprovalPolicy {
     const stored = readJson<Partial<ApprovalPolicy>>(this.path) ?? {}
-    return { auto: stored.auto ?? {}, remembered: stored.remembered ?? {} }
+    return { auto: stored.auto ?? {}, globalTools: stored.globalTools ?? {}, remembered: stored.remembered ?? {} }
   }
 
   private change(update: (policy: ApprovalPolicy) => void): ApprovalPolicy {
@@ -90,6 +93,25 @@ export class Approvals {
     return this.change((policy) => void (policy.auto[key] = on))
   }
 
+  /** Always allow `target` for every session in this approval profile and state directory. */
+  allowTool(key: string, target: string): ApprovalPolicy {
+    if (!(APPROVAL_KEYS as readonly string[]).includes(key)) throw invalid('Unknown harness.')
+    if (!target.trim()) throw invalid('A tool is required.')
+    return this.change((policy) => {
+      const targets = (policy.globalTools[key] ??= [])
+      if (!targets.includes(target)) targets.push(target)
+    })
+  }
+
+  revokeTool(key: string, target: string): ApprovalPolicy {
+    if (!(APPROVAL_KEYS as readonly string[]).includes(key)) throw invalid('Unknown harness.')
+    return this.change((policy) => {
+      const targets = policy.globalTools[key]?.filter((item) => item !== target) ?? []
+      if (targets.length) policy.globalTools[key] = targets
+      else delete policy.globalTools[key]
+    })
+  }
+
   /** Always allow `target` in this session. */
   remember(sessionId: string, target: string): ApprovalPolicy {
     if (!target.trim()) throw invalid('A tool is required.')

package/src/sessions/contracts.ts

@@ -10,6 +10,7 @@ export const runEventTypeSchema = z.enum([
   'context.snapshot',
   'message.delta',
   'message.completed',
+  'message.steered',
   'tool.started',
   'tool.completed',
   'retry.started',
@@ -35,6 +36,8 @@ export type RunEventType = z.infer<typeof runEventTypeSchema>
 
 const messageDeltaPayload = z.object({ messageId: z.string(), text: z.string() })
 const messageCompletedPayload = z.object({ messageId: z.string(), role: z.enum(['user', 'assistant']), text: z.string() })
+/** A message the person sent into the run while it was going; the model reads it from its next request on. */
+const messageSteeredPayload = z.object({ text: z.string() })
 const contextSnapshotPayload = z.object({
   systemPrompt: z.string().max(100_000),
   contextUpdate: z.string().max(100_000).optional(),
@@ -96,15 +99,37 @@ const approvalRequestedPayload = z.object({
 const approvalResolvedPayload = z.object({ approvalId: z.string(), decision: z.enum(['approved', 'denied', 'native']), automatic: approvalAutomaticSchema.optional() })
 export const questionOptionSchema = z.object({ label: z.string().min(1), description: z.string().optional() })
 export type QuestionOption = z.infer<typeof questionOptionSchema>
+const questionBatchFields = {
+  batchId: z.string().min(1).optional(),
+  batchIndex: z.number().int().min(1).max(5).optional(),
+  batchCount: z.number().int().min(1).max(5).optional()
+}
+const questionBatchRefinement = <T extends { batchId?: string; batchIndex?: number; batchCount?: number }>(value: T, context: z.RefinementCtx): void => {
+  const fields = [value.batchId, value.batchIndex, value.batchCount]
+  if (fields.some((field) => field !== undefined) && fields.some((field) => field === undefined)) {
+    context.addIssue({ code: z.ZodIssueCode.custom, message: 'Question batch fields must be supplied together.' })
+  }
+  if (value.batchIndex !== undefined && value.batchCount !== undefined && value.batchIndex > value.batchCount) {
+    context.addIssue({ code: z.ZodIssueCode.custom, message: 'Question batch index cannot exceed its count.' })
+  }
+}
 const questionRequestedPayload = z.object({
   questionId: z.string(),
   question: z.string().min(1),
+  summary: z.string().min(1).max(100).optional(),
   options: z.array(questionOptionSchema),
   multiSelect: z.boolean(),
   allowText: z.boolean(),
-  userOnly: z.boolean().optional()
-})
-const questionAnsweredPayload = z.object({ questionId: z.string(), selected: z.array(z.string()), text: z.string().optional() })
+  userOnly: z.boolean().optional(),
+  ...questionBatchFields
+}).superRefine(questionBatchRefinement)
+const questionAnsweredPayload = z.object({
+  questionId: z.string(),
+  selected: z.array(z.string()),
+  text: z.string().optional(),
+  notes: z.record(z.string(), z.string().max(10_000)).optional(),
+  ...questionBatchFields
+}).superRefine(questionBatchRefinement)
 /** A short emoji sequence, never words or numbers. */
 const reactionAddedPayload = z.object({ emoji: z.string().min(1).refine((text) => Buffer.byteLength(text) <= 16 && !/[A-Za-z0-9\s]/.test(text)) })
 /** A message this run's agent sent to (`to`) or received back from (`from`) another agent. */
@@ -196,6 +221,7 @@ export const runEventPayloadSchemas = {
   'context.snapshot': contextSnapshotPayload,
   'message.delta': messageDeltaPayload,
   'message.completed': messageCompletedPayload,
+  'message.steered': messageSteeredPayload,
   'tool.started': toolPayload,
   'tool.completed': toolPayload,
   'retry.started': retryStartedPayload,

package/src/sessions/conversation.test.ts

@@ -56,6 +56,62 @@ async function setup() {
 }
 
 describe('a whole reply, with a scripted model', () => {
+  it('joins async native children and persists one result receipt before the final reply', async () => {
+    const { harness, root, model, start, until, settled, of } = await setup()
+    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('native-child-brief')) return model.says('CHILD_EVIDENCE')
+      if (JSON.stringify(context.messages).includes('CHILD_EVIDENCE')) return model.says('Final with CHILD_EVIDENCE')
+      if (!context.messages.some(message => message.role === 'toolResult')) return model.calls(['spawn_subagent', { brief: 'native-child-brief' }])
+      return model.says('Draft before joining')
+    }
+    model.script(Array(8).fill(route))
+    const id = await start()
+    await until(() => settled(id))
+    expect(of(id).at(-1)?.type).toBe('completed')
+    expect(of(id).filter(event => event.type === 'message.completed').at(-1)?.payload).toMatchObject({ text: 'Final with CHILD_EVIDENCE' })
+    const { sessionFile } = await import('../prompt/compile')
+    const { readFileSync } = await import('node:fs')
+    const entries = readFileSync(sessionFile(join(root, 'sessions', 'a1'))!, 'utf8').trim().split('\n').map(line => JSON.parse(line))
+    expect(entries.filter(entry => entry.customType === 'xingular-subagent-results')).toHaveLength(1)
+    expect(model.requests()).toBeLessThanOrEqual(4)
+    expect(harness.runs.activeRunIds()).toEqual([])
+  })
+
+  it('uses blocking native results without adding an unsolicited duplicate delivery', async () => {
+    const { root, model, start, until, settled, of } = await setup()
+    model.script([model.calls(['spawn_subagent', { brief: 'Find proof', wait: true }]), model.says('INLINE_CHILD_PROOF'), model.says('Final')])
+    const id = await start()
+    await until(() => settled(id))
+    expect(of(id).at(-1)?.type).toBe('completed')
+    expect(model.lastToolResults().join('')).toContain('INLINE_CHILD_PROOF')
+    const { sessionFile } = await import('../prompt/compile')
+    const { readFileSync } = await import('node:fs')
+    expect(readFileSync(sessionFile(join(root, 'sessions', 'a1'))!, 'utf8')).not.toContain('"customType":"xingular-subagent-results"')
+    expect(model.requests()).toBe(3)
+  })
+
+  it('interrupts a parent waiting on a child question without deadlocking SDK abort', async () => {
+    const { harness, model, start, until, settled } = await setup()
+    const ai = await import('@earendil-works/pi-ai')
+    model.script([
+      model.calls(['spawn_subagent', { brief: 'Ask for a decision', wait: true }]),
+      ai.fauxAssistantMessage([ai.fauxToolCall('ask_user', { questions: [{ summary: 'A decision', question: 'Which approach?' }] })], { stopReason: 'toolUse' })
+    ])
+    let childRunId: string | null = null
+    harness.runs.listen((event, run) => { if (event.type === 'question.requested' && run?.relation === 'subagent') childRunId = event.runId })
+    const id = await start()
+    await until(() => childRunId !== null || settled(id))
+    expect(childRunId).not.toBeNull()
+    await harness.runs.interrupt(id)
+    const { loadRun } = await import('./runStore')
+    expect(loadRun(harness.env.root, id).status).toBe('interrupted')
+    expect(loadRun(harness.env.root, childRunId!).status).toBe('interrupted')
+    const { readEvents } = await import('./runStore')
+    expect(readEvents(harness.env.root, childRunId!).some(event => event.type === 'question.answered')).toBe(true)
+    expect(harness.runs.activeRunIds()).toEqual([])
+  })
+
   it('dispatches a registered command with notes without making a provider request', async () => {
     const { harness, model, start, until, settled, of } = await setup()
     const account = harness.accounts.context(harness.accounts.resolve(null, null))
@@ -147,4 +203,31 @@ describe('a whole reply, with a scripted model', () => {
     await until(() => settled(id))
     expect(model.lastToolResults().at(-1)).not.toContain('waiting in the Inbox')
   })
+
+  it('delivers a message sent during a tool call after that call, before the next request', async () => {
+    const { harness, model, call, start, until, settled, of } = await setup()
+    model.script([model.calls(['bash', { command: 'ls' }]), model.says('Noted.')])
+    const id = await start({ tools: { allow: ['read', 'bash'], gated: ['bash'] } })
+    await until(() => of(id).some((event) => event.type === 'approval.requested'))
+    const approval = of(id).find((event) => event.type === 'approval.requested')!.payload as { approvalId: string }
+    await call('runs.steer', { runId: id, text: 'Also check the logs.' })
+    harness.runs.resolveApproval(id, approval.approvalId, 'denied')
+    await until(() => settled(id))
+    const types = of(id).map((event) => event.type)
+    expect(of(id).find((event) => event.type === 'message.steered')?.payload).toEqual({ text: 'Also check the logs.' })
+    expect(types.indexOf('message.steered')).toBeGreaterThan(types.indexOf('approval.resolved'))
+    expect(model.requests()).toBe(2)
+    // The context update reaches the model as a user-role message too; the prompt and the steer come last.
+    expect(model.lastUserTexts().slice(-2)).toEqual(['Go.', 'Also check the logs.'])
+    expect(of(id).at(-1)?.type).toBe('completed')
+  })
+
+  it('refuses a message once the reply has ended, so the app sends it as a new reply', async () => {
+    const { call, model, start, until, settled, of } = await setup()
+    model.script([model.says('Done.')])
+    const id = await start()
+    await until(() => settled(id))
+    await expect(call('runs.steer', { runId: id, text: 'Too late.' })).rejects.toMatchObject({ code: 'run_not_active' })
+    expect(of(id).some((event) => event.type === 'message.steered')).toBe(false)
+  })
 })

package/src/sessions/lineageJoin.ts

@@ -16,7 +16,7 @@ function directChildren(root: string, runId: string): RunSummary[] {
   try {
     return runFamily(root, runId).runs
       .map(({ run }) => run)
-      .filter((run) => run.parentRunId === runId)
+      .filter((run) => run.parentRunId === runId && run.relation !== 'subagent')
       .map((run) => ({ id: run.id, status: run.status, goal: run.goal, terminalReason: run.terminalReason }))
   } catch {
     return []

package/src/sessions/policy.ts

@@ -17,6 +17,10 @@ export interface ScopeDecision {
   allowed: boolean
   /** Not allowed as it stands, but a person may approve this one call. */
   requiresApproval?: boolean
+  /** Per-tool remembered approvals never answer this call. */
+  humanOnly?: boolean
+  /** Whether the global always-approve switch may answer a human-only call. Defaults to false. */
+  allowGlobalApproval?: boolean
   reason?: string | null
 }
 

package/src/sessions/questionBatches.test.ts

@@ -0,0 +1,110 @@
+import { mkdtempSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, expect, test } from 'vitest'
+
+import { closeIndex } from '../core/index'
+import { runEventPayloadSchemas, runRecordSchema, type RunEvent } from './contracts'
+import { RunRegistry } from './registry'
+import { readEvents, saveRun } from './runStore'
+
+const roots: string[] = []
+afterEach(() => {
+  for (const root of roots.splice(0)) closeIndex(root)
+})
+
+function fixture() {
+  const root = mkdtempSync(join(tmpdir(), 'harness-question-batch-'))
+  roots.push(root)
+  saveRun(root, runRecordSchema.parse({
+    id: 'run-1',
+    sessionId: 'session-1',
+    projectId: null,
+    mode: 'chat',
+    harness: 'pi',
+    sessionType: 'structured',
+    nativeSessionId: null,
+    workingDirectory: null,
+    worktreeId: null,
+    goal: null,
+    status: 'running',
+    startedAt: 'start',
+    endedAt: null
+  }))
+  const registry = new RunRegistry({ root: () => root })
+  const run = registry.start('session-1', 'run-1')
+  return { root, registry, run }
+}
+
+test('question batches validate all answers before resolving and retain choice notes', async () => {
+  const { root, registry, run } = fixture()
+  expect(() => run.requestAnswers([])).toThrow(/between one and five/)
+  expect(() => run.requestAnswers(Array.from({ length: 6 }, () => ({ question: 'Q', options: [], multiSelect: false, allowText: true })))).toThrow(/between one and five/)
+
+  const result = run.requestAnswers([
+    { summary: 'Project scope', question: 'What should change?', options: [{ label: 'UI' }, { label: 'API' }], multiSelect: true, allowText: true },
+    { summary: 'Target date', question: 'When should it ship?', options: [{ label: 'Soon' }, { label: 'Later' }], multiSelect: false, allowText: false }
+  ])
+  let settled = false
+  void result.then(() => { settled = true })
+
+  const requested = readEvents(root, 'run-1').filter((event) => event.type === 'question.requested')
+  expect(requested).toHaveLength(2)
+  const [first, second] = requested.map((event) => event.payload as { questionId: string; summary: string; batchId: string; batchIndex: number; batchCount: number })
+  expect(first).toMatchObject({ summary: 'Project scope', batchIndex: 1, batchCount: 2 })
+  expect(second).toMatchObject({ summary: 'Target date', batchId: first.batchId, batchIndex: 2, batchCount: 2 })
+  expect(() => registry.answerQuestion('run-1', first.questionId, { selected: ['UI'] })).toThrow(/together/)
+
+  expect(() => registry.answerQuestions('run-1', first.batchId, [
+    { questionId: first.questionId, answer: { selected: ['UI'] } },
+    { questionId: second.questionId, answer: { selected: ['Later'], notes: { Soon: 'wrong choice' } } }
+  ])).toThrow(/selected choices/)
+  await Promise.resolve()
+  expect(settled).toBe(false)
+
+  registry.answerQuestions('run-1', first.batchId, [
+    { questionId: second.questionId, answer: { selected: ['Soon'] } },
+    { questionId: first.questionId, answer: { selected: ['UI'], notes: { UI: 'Keep keyboard navigation.' } } }
+  ])
+  await expect(result).resolves.toEqual([
+    { selected: ['UI'], notes: { UI: 'Keep keyboard navigation.' } },
+    { selected: ['Soon'] }
+  ])
+
+  const answered = readEvents(root, 'run-1').filter((event) => event.type === 'question.answered')
+  expect(answered).toHaveLength(2)
+  expect(answered.find((event) => (event.payload as { questionId: string }).questionId === first.questionId)?.payload).toMatchObject({
+    batchId: first.batchId,
+    batchIndex: 1,
+    batchCount: 2,
+    notes: { UI: 'Keep keyboard navigation.' }
+  })
+})
+
+test('legacy single questions remain valid alongside batch event metadata', () => {
+  const { root, registry, run } = fixture()
+  const answer = run.requestAnswer({ question: 'Continue?', options: [{ label: 'Yes' }], multiSelect: false, allowText: false })
+  const request = readEvents(root, 'run-1').find((event) => event.type === 'question.requested')!
+  expect(runEventPayloadSchemas['question.requested'].safeParse(request.payload).success).toBe(true)
+  expect(runEventPayloadSchemas['question.requested'].safeParse({ ...(request.payload as object), batchId: 'partial' }).success).toBe(false)
+  registry.answerQuestion('run-1', (request.payload as { questionId: string }).questionId, { selected: ['Yes'] })
+  return expect(answer).resolves.toEqual({ selected: ['Yes'] })
+})
+
+test('answer batch method rejects duplicate and foreign question ids without settling the batch', async () => {
+  const { root, registry, run } = fixture()
+  const result = run.requestAnswers([
+    { summary: 'First', question: 'First?', options: [], multiSelect: false, allowText: true },
+    { summary: 'Second', question: 'Second?', options: [], multiSelect: false, allowText: true }
+  ])
+  const requested = readEvents(root, 'run-1').filter((event) => event.type === 'question.requested')
+  const [first, second] = requested.map((event) => event.payload as { questionId: string; batchId: string })
+  const answers = [{ questionId: first.questionId, answer: { selected: [], text: 'a' } }, { questionId: second.questionId, answer: { selected: [], text: 'b' } }]
+  expect(() => registry.answerQuestions('run-1', 'other-batch', answers)).toThrow(/batch/)
+  expect(() => registry.answerQuestions('run-1', first.batchId, [answers[0], answers[0]])).toThrow(/batch/)
+  expect(() => registry.answerQuestions('another-run', first.batchId, answers)).toThrow(/batch/)
+  const events: RunEvent[] = readEvents(root, 'run-1')
+  expect(events.filter((event) => event.type === 'question.answered')).toHaveLength(0)
+  registry.answerQuestions('run-1', first.batchId, answers)
+  await expect(result).resolves.toHaveLength(2)
+})