@xingular/harness 2.0.0 → 2.0.1-unstable

package/src/sessions/extensionUi.test.ts

@@ -1,65 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { extensionUi, type ExtensionNotice } from './extensionUi'
-import type { QuestionAnswer, QuestionInput } from './registry'
-
-function host(answer: QuestionAnswer | Promise<QuestionAnswer>) {
-  const asked: QuestionInput[] = []
-  const notices: ExtensionNotice[] = []
-  const ui = extensionUi({ ask: async (input) => (asked.push(input), answer), notice: (notice) => void notices.push(notice) })
-  return { ui, asked, notices }
-}
-
-describe('what an extension can ask and show without a terminal', () => {
-  it('turns a choice, a yes or no, and typed text into questions', async () => {
-    const choice = host({ selected: ['Block'] })
-    expect(await choice.ui.select('Allow this command?', ['Allow', 'Block'])).toBe('Block')
-    expect(choice.asked[0]).toEqual({ question: 'Allow this command?', options: [{ label: 'Allow' }, { label: 'Block' }], multiSelect: false, allowText: false })
-
-    const yes = host({ selected: ['Yes'] })
-    expect(await yes.ui.confirm('Clear the session?', 'All messages will be lost.')).toBe(true)
-    expect(yes.asked[0]).toMatchObject({ question: 'Clear the session?\n\nAll messages will be lost.', options: [{ label: 'Yes' }, { label: 'No' }] })
-    expect(await host({ selected: ['No'] }).ui.confirm('Sure?', '')).toBe(false)
-    // No answer is a no, never a yes.
-    expect(await host({ selected: [] }).ui.confirm('Sure?', '')).toBe(false)
-
-    const typed = host({ selected: [], text: 'main' })
-    expect(await typed.ui.input('Branch', 'a name')).toBe('main')
-    expect(typed.asked[0]).toMatchObject({ question: 'Branch (a name)', options: [], allowText: true })
-    expect(await host({ selected: [] }).ui.input('Branch')).toBeUndefined()
-    expect(await host({ selected: [], text: 'edited' }).ui.editor('Edit', 'before')).toBe('edited')
-  })
-
-  it('gives up a dialog when the extension dismisses it or its time runs out', async () => {
-    const never = new Promise<QuestionAnswer>(() => undefined)
-    expect(await host(never).ui.confirm('Sure?', '', { timeout: 10 })).toBe(false)
-    const controller = new AbortController()
-    const pending = host(never).ui.select('Pick', ['a'], { signal: controller.signal })
-    controller.abort()
-    expect(await pending).toBeUndefined()
-  })
-
-  it('relays notifications, status lines and text widgets, and ignores what needs a terminal', async () => {
-    const { ui, notices } = host({ selected: [] })
-    ui.notify('Blocked', 'warning')
-    ui.setStatus('budget', '3 of 10 requests')
-    ui.setStatus('budget', undefined)
-    ui.setWidget('plan', ['One', 'Two'])
-    ui.setWidget('plan', (() => ({})) as never)
-    ui.setTitle('Review')
-    ui.setFooter(undefined)
-    ui.setWorkingMessage('thinking')
-    expect(notices).toEqual([
-      { kind: 'notify', level: 'warning', text: 'Blocked' },
-      { kind: 'status', key: 'budget', text: '3 of 10 requests' },
-      { kind: 'status', key: 'budget', text: '' },
-      { kind: 'widget', key: 'plan', text: 'One\nTwo' },
-      { kind: 'title', text: 'Review' }
-    ])
-    expect(await ui.custom((() => ({})) as never)).toBeUndefined()
-    expect(ui.getEditorText()).toBe('')
-    // Styling returns the text unchanged: there is nothing to colour.
-    expect((ui.theme as unknown as { fg(color: string, text: string): string }).fg('accent', 'plain')).toBe('plain')
-    expect(ui.setTheme('dark')).toMatchObject({ success: false })
-  })
-})

package/src/sessions/extensionUi.ts

@@ -1,102 +0,0 @@
-// What a Pi extension can show and ask in a session that has no terminal. Pi's own terminal
-// draws an extension's dialogs and status lines; here they become the run's question events and
-// notices, the same subset Pi's RPC mode supports. Anything that needs a real terminal (custom
-// components, key handlers, themes) does nothing, as it does there.
-import type { ExtensionUIContext } from '@earendil-works/pi-coding-agent'
-
-import type { QuestionAnswer, QuestionInput } from './registry'
-
-/** A status line, a notification, or an error from an extension. */
-export interface ExtensionNotice {
-  kind: 'notify' | 'status' | 'widget' | 'title' | 'error'
-  /** `notify` only. */
-  level?: 'info' | 'warning' | 'error'
-  /** The extension's own name for a status entry or a widget, so a later one replaces it. */
-  key?: string
-  /** The text. Empty clears a status entry or a widget. */
-  text: string
-  /** The file of the extension, for an error. */
-  extension?: string
-}
-
-export interface ExtensionHost {
-  ask(input: QuestionInput): Promise<QuestionAnswer>
-  notice(notice: ExtensionNotice): void
-}
-
-const MAX_TEXT = 4_000
-const clip = (text: string): string => (text.length > MAX_TEXT ? `${text.slice(0, MAX_TEXT)}…` : text)
-
-/** A dialog that Pi can dismiss on its own: by a signal, or after a time. */
-function dismissable<T>(answer: Promise<T>, fallback: T, options?: { signal?: AbortSignal; timeout?: number }): Promise<T> {
-  if (!options?.signal && !options?.timeout) return answer
-  return new Promise<T>((resolve) => {
-    let timer: ReturnType<typeof setTimeout> | undefined
-    const done = (value: T): void => {
-      if (timer) clearTimeout(timer)
-      resolve(value)
-    }
-    if (options.signal?.aborted) return done(fallback)
-    options.signal?.addEventListener('abort', () => done(fallback), { once: true })
-    if (options.timeout) timer = setTimeout(() => done(fallback), options.timeout)
-    void answer.then(done, () => done(fallback))
-  })
-}
-
-// Text styling has no meaning without a terminal: every style returns the text it was given.
-const plainTheme = new Proxy({}, { get: () => (...args: unknown[]) => String(args[args.length - 1] ?? '') })
-
-export function extensionUi(host: ExtensionHost): ExtensionUIContext {
-  const context = {
-    select: (title: string, options: string[], opts?: { signal?: AbortSignal; timeout?: number }) =>
-      dismissable(
-        host.ask({ question: clip(title), options: options.map((label) => ({ label })), multiSelect: false, allowText: false }).then((answer) => answer.selected[0]),
-        undefined,
-        opts
-      ),
-    confirm: (title: string, message: string, opts?: { signal?: AbortSignal; timeout?: number }) =>
-      dismissable(
-        host.ask({ question: clip(message ? `${title}\n\n${message}` : title), options: [{ label: 'Yes' }, { label: 'No' }], multiSelect: false, allowText: false }).then((answer) => answer.selected[0] === 'Yes'),
-        false,
-        opts
-      ),
-    input: (title: string, placeholder?: string, opts?: { signal?: AbortSignal; timeout?: number }) =>
-      dismissable(
-        host.ask({ question: clip(placeholder ? `${title} (${placeholder})` : title), options: [], multiSelect: false, allowText: true }).then((answer) => answer.text || undefined),
-        undefined,
-        opts
-      ),
-    editor: (title: string, prefill?: string) =>
-      host.ask({ question: clip(prefill ? `${title}\n\n${prefill}` : title), options: [], multiSelect: false, allowText: true }).then((answer) => answer.text || undefined),
-    notify: (message: string, level?: 'info' | 'warning' | 'error') => host.notice({ kind: 'notify', level: level ?? 'info', text: clip(message) }),
-    setStatus: (key: string, text: string | undefined) => host.notice({ kind: 'status', key, text: clip(text ?? '') }),
-    setWidget: (key: string, content: unknown) => {
-      // Only lines of text can be shown; a component needs a terminal.
-      if (content === undefined || Array.isArray(content)) host.notice({ kind: 'widget', key, text: clip(((content as string[] | undefined) ?? []).join('\n')) })
-    },
-    setTitle: (title: string) => host.notice({ kind: 'title', text: clip(title) }),
-    onTerminalInput: () => () => {},
-    setWorkingMessage: () => {},
-    setWorkingVisible: () => {},
-    setWorkingIndicator: () => {},
-    setHiddenThinkingLabel: () => {},
-    setFooter: () => {},
-    setHeader: () => {},
-    custom: async () => undefined,
-    pasteToEditor: () => {},
-    setEditorText: () => {},
-    getEditorText: () => '',
-    addAutocompleteProvider: () => {},
-    setEditorComponent: () => {},
-    getEditorComponent: () => undefined,
-    get theme() {
-      return plainTheme
-    },
-    getAllThemes: () => [],
-    getTheme: () => undefined,
-    setTheme: () => ({ success: false, error: 'There is no terminal to theme in this session.' }),
-    getToolsExpanded: () => false,
-    setToolsExpanded: () => {}
-  }
-  return context as unknown as ExtensionUIContext
-}

package/src/sessions/history.ts

@@ -1,51 +0,0 @@
-// Which native history a session opens. The prompt compiler compares against this file and Pi
-// opens it, so both always see the same conversation, including after a restart.
-import { readFileSync, realpathSync } from 'node:fs'
-import { isAbsolute, relative } from 'node:path'
-
-import { HarnessError } from '../core/errors'
-import { sessionFile } from '../prompt/compile'
-
-export interface HistorySelection {
-  sessionDir: string
-  /** A recorded history to continue, with the native session id it must still carry. */
-  resume?: { sessionFile?: string | null; nativeSessionId?: string | null } | null
-}
-
-const unavailable = (): HarnessError => new HarnessError('native_resume_unavailable', 'The saved conversation is unavailable; this reply cannot be continued.')
-
-/** The session file's own id, when the file is a native history inside `sessionDir`. */
-function nativeId(sessionDir: string, path: string): string {
-  const file = realpathSync(path)
-  const within = relative(realpathSync(sessionDir), file)
-  if (within.startsWith('..') || isAbsolute(within) || !file.endsWith('.jsonl')) throw new Error('Outside history')
-  const header = JSON.parse(readFileSync(file, 'utf8').split('\n', 1)[0]) as { type?: string; id?: string }
-  if (header.type !== 'session' || !header.id) throw new Error('Missing session identity')
-  return header.id
-}
-
-/**
- * The history to open: the recorded one for an explicit continuation, else the newest in the
- * session's folder, else none (a fresh history). An explicit continuation never falls back to
- * another session or a fresh history.
- */
-export function selectHistory(selection: HistorySelection): string | null {
-  const resume = selection.resume
-  if (resume?.sessionFile || resume?.nativeSessionId) {
-    try {
-      if (!resume.sessionFile || !resume.nativeSessionId) throw new Error('Missing history')
-      if (nativeId(selection.sessionDir, resume.sessionFile) !== resume.nativeSessionId) throw new Error('Different history')
-      return realpathSync(resume.sessionFile)
-    } catch {
-      throw unavailable()
-    }
-  }
-  const newest = sessionFile(selection.sessionDir)
-  if (!newest) return null
-  try {
-    nativeId(selection.sessionDir, newest)
-    return realpathSync(newest)
-  } catch {
-    throw unavailable()
-  }
-}

package/src/sessions/lineageJoin.ts

@@ -1,75 +0,0 @@
-import type { AgentBeforeSettleEvent, BoundaryResult, ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
-
-import { takeChars } from '../core/text'
-import { isActiveStatus } from './contracts'
-import { readEvents, runFamily } from './runStore'
-import type { InlineExtension } from '../plugins/firstParty'
-
-interface RunSummary {
-  id: string
-  status: string
-  goal: string | null
-  terminalReason: string | null
-}
-
-function directChildren(root: string, runId: string): RunSummary[] {
-  try {
-    return runFamily(root, runId).runs
-      .map(({ run }) => run)
-      .filter((run) => run.parentRunId === runId && run.relation !== 'subagent')
-      .map((run) => ({ id: run.id, status: run.status, goal: run.goal, terminalReason: run.terminalReason }))
-  } catch {
-    return []
-  }
-}
-
-function settled(root: string, runId: string): boolean {
-  return directChildren(root, runId).every((child) => !isActiveStatus(child.status))
-}
-
-function alreadyIncluded(event: AgentBeforeSettleEvent, runId: string): boolean {
-  return JSON.stringify(event.context.contextMessages).includes(runId)
-}
-
-function childReport(root: string, child: RunSummary): string {
-  const reply = readEvents(root, child.id)
-    .filter((event) => event.type === 'message.completed' && (event.payload as { role?: unknown }).role === 'assistant')
-    .at(-1)
-  const payload = reply?.payload as { text?: unknown } | undefined
-  const text = payload && typeof payload.text === 'string' ? takeChars(payload.text, 8000) : ''
-  const lines = [`Run ${child.id} · ${child.status}`, `Goal: ${child.goal?.trim() || '(not recorded)'}`]
-  if (text) lines.push(`Result:\n${text}`)
-  if (child.status !== 'completed' && child.terminalReason) lines.push(`Stopped because: ${child.terminalReason}`)
-  return lines.join('\n')
-}
-
-async function waitForChildren(root: string, runId: string, signal?: AbortSignal): Promise<boolean> {
-  while (!signal?.aborted) {
-    if (settled(root, runId)) return true
-    await new Promise<void>((resolve) => setTimeout(resolve, 250))
-  }
-  return false
-}
-
-function install(pi: ExtensionAPI, root: string, runId: string): void {
-  pi.on('agent_before_settle', async (event, context: ExtensionContext): Promise<BoundaryResult | undefined> => {
-    if (event.outcome !== 'completed' || settled(root, runId)) return undefined
-    const completed = await waitForChildren(root, runId, context.signal)
-    if (!completed || context.signal?.aborted) return undefined
-
-    const unreported = directChildren(root, runId).filter((child) => !alreadyIncluded(event, child.id))
-    if (!unreported.length) return undefined
-    const summary = takeChars(
-      `Independent run results. Include each result or failure in the reply; the user may open each run for its full history.\n\n${unreported.map((child) => childReport(root, child)).join('\n\n')}`,
-      32_000
-    )
-    return {
-      entries: [...event.entries, { type: 'custom_message', customType: 'run-lineage-results', content: summary, display: false }],
-      continue: true
-    }
-  })
-}
-
-export function runLineageJoin(root: string, runId: string): InlineExtension {
-  return { name: 'run-lineage-join', factory: (pi: ExtensionAPI) => install(pi, root, runId) }
-}

package/src/sessions/policy.ts

@@ -1,36 +0,0 @@
-// What the embedding application decides about a session's tool calls. The harness asks; it
-// never assumes: with no policy, every enabled tool may run and gated tools ask the user.
-import type { CallerContext } from '../memory/caller'
-import type { ApprovalFacts } from './approvals'
-import type { RunRecord } from './contracts'
-
-export interface ToolCall {
-  run: RunRecord
-  caller: CallerContext
-  tool: string
-  args: unknown
-}
-
-export interface ScopeDecision {
-  /** The run is unattended: nothing may ask a person, so what is not allowed is refused. */
-  automatic?: boolean
-  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
-}
-
-export interface ToolPolicy {
-  /** Whether the call is inside what this run may do. Asked before every tool call. */
-  scope?(call: ToolCall): Promise<ScopeDecision>
-  /** Whether the tool is still switched on. Asked before a call and again after an approval; throws to block. */
-  authorize?(call: ToolCall): Promise<void>
-  /** Facts about a pending approval that only the application knows. */
-  approval?(input: { run: RunRecord; target: string; operation?: { tool: string; args: unknown } }): Promise<ApprovalFacts>
-  /** The connected apps this session may reach, out of those its scope already allows. */
-  connections?(input: { sessionId: string; runId: string | null; caller: CallerContext; connectionIds: string[] }): Promise<string[]>
-}

package/src/sessions/pricing.ts

@@ -1,60 +0,0 @@
-// List-price cost of token usage, for when a provider reports tokens but no cost.
-import type { ModelRuntime } from '@earendil-works/pi-coding-agent'
-
-/** Dollars per million tokens. */
-export interface PriceRates {
-  input: number
-  output: number
-  cacheRead: number
-  cacheWrite: number
-  /** The highest tier whose threshold the request's whole input exceeds replaces the base rates. */
-  tiers?: Array<{ input: number; output: number; cacheRead: number; cacheWrite: number; inputTokensAbove: number }>
-}
-
-export interface PricedTokens {
-  inputTokens?: number
-  outputTokens?: number
-  cacheReadTokens?: number
-  cacheWriteTokens?: number
-}
-
-/** The cost of one request at `rates`. Same arithmetic as Pi's own `calculateCost`. */
-export function costAt(rates: PriceRates, usage: PricedTokens): number {
-  const input = usage.inputTokens ?? 0
-  const cacheRead = usage.cacheReadTokens ?? 0
-  const cacheWrite = usage.cacheWriteTokens ?? 0
-  const whole = input + cacheRead + cacheWrite
-  let applied: Omit<PriceRates, 'tiers'> = rates
-  let threshold = -1
-  for (const tier of rates.tiers ?? []) {
-    if (whole > tier.inputTokensAbove && tier.inputTokensAbove > threshold) {
-      applied = tier
-      threshold = tier.inputTokensAbove
-    }
-  }
-  return (applied.input * input + applied.output * (usage.outputTokens ?? 0) + applied.cacheRead * cacheRead + applied.cacheWrite * cacheWrite) / 1_000_000
-}
-
-type Catalogue = { getModel(provider: string, model: string): { cost?: PriceRates } | undefined }
-let catalogue: Promise<Catalogue> | null = null
-
-async function loadCatalogue(): Promise<Catalogue> {
-  const { ModelRuntime } = await import('@earendil-works/pi-coding-agent')
-  const none = { read: async () => undefined, list: async () => [], modify: async () => undefined, delete: async () => undefined }
-  return (await ModelRuntime.create({ credentials: none, modelsPath: null, refreshOnCreate: false })) as ModelRuntime as unknown as Catalogue
-}
-
-/**
- * The list rates Pi's catalogue has for a model, or null when it has none. A dated model id
- * (`…-20250929`) also matches its undated entry. Rates of zero are "unknown", not "free".
- */
-export async function modelRates(provider: string | undefined, model: string | undefined, lookup: Promise<Catalogue> = (catalogue ??= loadCatalogue())): Promise<PriceRates | null> {
-  if (!provider || !model) return null
-  const models = await lookup.catch(() => null)
-  if (!models) return null
-  for (const id of new Set([model, model.replace(/-\d{8}$/, '')])) {
-    const cost = models.getModel(provider, id)?.cost
-    if (cost && (cost.input > 0 || cost.output > 0)) return cost
-  }
-  return null
-}

package/src/sessions/questionBatches.test.ts

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

package/src/sessions/reasoningSummaries.ts

@@ -1,59 +0,0 @@
-export const MAX_REASONING_SUMMARY_CHARS = 4_000
-
-export const REASONING_SUMMARY_APIS = new Set([
-  'openai-responses',
-  'azure-openai-responses',
-  'openai-codex-responses'
-])
-
-type RecordValue = Record<string, unknown>
-
-function isRecord(value: unknown): value is RecordValue {
-  return Boolean(value && typeof value === 'object' && !Array.isArray(value))
-}
-
-function cleanSummary(value: string): string | undefined {
-  let text = ''
-  for (const character of value.trim()) {
-    if (text.length + character.length > MAX_REASONING_SUMMARY_CHARS) break
-    text += character
-  }
-  return text.trim() || undefined
-}
-
-/** Add the Responses API summary request while preserving the provider-selected effort. */
-export function requestConciseReasoningSummary(payload: unknown): { payload: unknown; requested: boolean } {
-  if (!isRecord(payload) || !isRecord(payload.reasoning)) return { payload, requested: false }
-  const effort = payload.reasoning.effort
-  if (typeof effort !== 'string' || ['none', 'off'].includes(effort.toLowerCase())) return { payload, requested: false }
-  return {
-    payload: { ...payload, reasoning: { ...payload.reasoning, summary: 'concise' } },
-    requested: true
-  }
-}
-
-/** Pi preserves the provider reasoning item for both WebSocket and SSE replay.
- * Read only its explicit summary: Pi's generic thinking field can also contain raw reasoning.
- */
-export function completedReasoningSummary(message: unknown): string | undefined {
-  if (!isRecord(message) || message.role !== 'assistant' || typeof message.api !== 'string' || !REASONING_SUMMARY_APIS.has(message.api) || !Array.isArray(message.content)) return undefined
-  const parts: string[] = []
-  const seen = new Set<string>()
-  for (const block of message.content) {
-    if (!isRecord(block) || block.type !== 'thinking' || typeof block.thinkingSignature !== 'string') continue
-    try {
-      const item: unknown = JSON.parse(block.thinkingSignature)
-      if (!isRecord(item) || item.type !== 'reasoning' || !Array.isArray(item.summary)) continue
-      if (typeof item.id === 'string') {
-        if (seen.has(item.id)) continue
-        seen.add(item.id)
-      }
-      for (const part of item.summary) {
-        if (isRecord(part) && part.type === 'summary_text' && typeof part.text === 'string') parts.push(part.text)
-      }
-    } catch {
-      // Signatures of other formats, or incomplete items, are not summary evidence.
-    }
-  }
-  return cleanSummary(parts.join('\n\n'))
-}