@xingular/harness 0.1.7 → 1.1.1

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'))
-}

package/src/sessions/registry.ts

@@ -1,381 +0,0 @@
-// Live runs. Assigns per-run sequence numbers, validates every event against the contract,
-// persists it, hands it to listeners, and tracks interrupt, approval, and question handlers.
-import { randomUUID } from 'node:crypto'
-
-import { log } from '../core/bus'
-import { HarnessError } from '../core/errors'
-import type { AutomaticReason } from './approvals'
-import { isActiveStatus, runEventSchema, type QuestionOption, type RunEvent, type RunEventType, type RunRecord } from './contracts'
-import { findRun, persistEvent, readEvents, runFamily } from './runStore'
-
-export type ApprovalDecision = 'approved' | 'denied' | 'native'
-
-export interface ApprovalInput {
-  requestId?: string
-  operation?: { tool: string; args: Record<string, unknown> }
-  target: string
-  action: string
-  screenshotRef?: string
-  /** A tool the user may choose to always allow for this session. */
-  rememberable?: boolean
-  /** `switch`: only the "always approve" switch may grant it. `none`: a person always decides. */
-  standing?: 'full' | 'switch' | 'none'
-  /** How long to wait for a decision before the request counts as denied. */
-  timeoutMs?: number
-}
-
-export interface QuestionInput {
-  requestId?: string
-  userOnly?: boolean
-  summary?: string
-  question: string
-  options: QuestionOption[]
-  multiSelect: boolean
-  allowText: boolean
-}
-
-export interface QuestionAnswer {
-  selected: string[]
-  text?: string
-  /** Optional notes keyed by the selected choice label. */
-  notes?: Record<string, string>
-}
-
-interface QuestionBatchMetadata {
-  batchId: string
-  batchIndex: number
-  batchCount: number
-}
-
-interface PendingQuestion {
-  runId: string
-  input: QuestionInput
-  batch?: QuestionBatchMetadata
-  resolve: (answer: QuestionAnswer) => void
-}
-
-export interface ActiveRun {
-  runId: string
-  sessionId: string
-  emit(type: RunEventType, payload: unknown, native?: unknown): void
-  onInterrupt(handler: () => Promise<void> | void): void
-  /** Hands a message to the model after its current step; the session registers how. */
-  onSteer(handler: (text: string) => Promise<void> | void): void
-  /** Resolves when the user decides; only the approval with this exact id can be resolved by it. */
-  requestApproval(input: ApprovalInput): Promise<ApprovalDecision>
-  /** Asks the user a question and resolves with their answer. */
-  requestAnswer(input: QuestionInput): Promise<QuestionAnswer>
-  /** Asks one to five related questions and resolves only after the whole batch is answered. */
-  requestAnswers(inputs: QuestionInput[]): Promise<QuestionAnswer[]>
-  finish(outcome: 'completed' | 'failed' | 'interrupted', failure?: { code: string; message: string }): void
-  readonly finished: boolean
-}
-
-/** Called with every persisted event, and the run's record as it is after that event. */
-export type RunListener = (event: RunEvent, run: RunRecord | null) => void
-
-export interface RegistryOptions {
-  root: () => string
-  /** Why this approval can be granted without asking, if it can. */
-  automatic?: (run: RunRecord, target: string, operation: ApprovalInput['operation'], standing: 'full' | 'switch') => Promise<AutomaticReason | null>
-  /** Called when a run stops being live, whatever its outcome. */
-  ended?: (runId: string, sessionId: string) => void
-  /** Removes secrets from an event before it is stored or shown. */
-  redact?: (event: RunEvent) => void
-}
-
-type LiveRun = ActiveRun & { interrupt: () => Promise<void>; steer: (text: string) => Promise<void> }
-
-export class RunRegistry {
-  private readonly runs = new Map<string, LiveRun>()
-  private readonly approvals = new Map<string, { runId: string; resolve: (decision: ApprovalDecision) => void }>()
-  private readonly questions = new Map<string, PendingQuestion>()
-  private readonly nativeCleared = new Map<string, string>()
-  private readonly stopping = new Set<string>()
-  private readonly listeners: RunListener[] = []
-
-  constructor(private readonly options: RegistryOptions) {}
-
-  /** Observers see events after they are persisted, in order. */
-  listen(listener: RunListener): void {
-    this.listeners.push(listener)
-  }
-
-  private deliver(event: RunEvent): boolean {
-    const root = this.options.root()
-    try {
-      this.options.redact?.(event)
-      if (!persistEvent(root, event)) return false
-    } catch (error) {
-      log(`could not persist event for ${event.runId}: ${error instanceof Error ? error.message : String(error)}`)
-      return false
-    }
-    const run = findRun(root, event.runId)
-    for (const listener of this.listeners) {
-      try {
-        listener(event, run)
-      } catch (error) {
-        log('a run listener failed', error instanceof Error ? error.message : String(error))
-      }
-    }
-    return true
-  }
-
-  /** Starts tracking a run whose record is already saved. */
-  start(sessionId: string, runId: string = randomUUID()): ActiveRun {
-    let sequence = 0
-    try {
-      sequence = readEvents(this.options.root(), runId).reduce((highest, event) => Math.max(highest, event.sequence + 1), 0)
-    } catch {
-      sequence = 0
-    }
-    let finished = false
-    const interruptHandlers: Array<() => Promise<void> | void> = []
-    let steerHandler: ((text: string) => Promise<void> | void) | null = null
-    const waitingStatus = (): string =>
-      [...this.approvals.values()].some((request) => request.runId === runId) ? 'waiting_for_approval' : [...this.questions.values()].some((request) => request.runId === runId) ? 'waiting_for_input' : 'running'
-
-    const requestQuestion = (input: QuestionInput, batch?: QuestionBatchMetadata, statusEvent = true): Promise<QuestionAnswer> => {
-      const { requestId, ...payload } = input
-      const questionId = requestId ?? randomUUID()
-      if (finished || this.nativeCleared.delete(questionId)) return Promise.resolve({ selected: [] })
-      if (this.questions.has(questionId)) throw new HarnessError('invalid_request', 'This question id is already pending.')
-      return new Promise<QuestionAnswer>((resolve) => {
-        this.questions.set(questionId, {
-          runId,
-          input,
-          ...(batch ? { batch } : {}),
-          resolve: (answer) => {
-            this.questions.delete(questionId)
-            emit('question.answered', { questionId, ...answer, ...(batch ?? {}) })
-            emit('status.changed', { status: waitingStatus() })
-            resolve(answer)
-          }
-        })
-        emit('question.requested', { questionId, ...payload, ...(batch ?? {}) })
-        if (statusEvent) emit('status.changed', { status: 'waiting_for_input' })
-      })
-    }
-
-    const emit = (type: RunEventType, payload: unknown, native?: unknown): void => {
-      if (finished) return
-      const parsed = runEventSchema.safeParse({ id: randomUUID(), runId, sessionId, sequence, timestamp: new Date().toISOString(), type, payload, ...(native === undefined ? {} : { native }) })
-      if (!parsed.success) {
-        log(`dropped invalid ${type} event for run ${runId}`)
-        return
-      }
-      sequence += 1
-      this.deliver(parsed.data)
-    }
-
-    const run: LiveRun = {
-      runId,
-      sessionId,
-      emit,
-      onInterrupt: (handler) => void interruptHandlers.push(handler),
-      onSteer: (handler) => {
-        steerHandler = handler
-      },
-      steer: async (text) => {
-        if (finished || !steerHandler) throw new HarnessError('run_not_active', 'This run is not accepting messages.')
-        await steerHandler(text)
-      },
-      requestApproval: async (input) => {
-        const { requestId, standing = 'full', timeoutMs, ...payload } = input
-        const approvalId = requestId ?? randomUUID()
-        // What the user already allowed is known here; if it cannot be read, ask as usual.
-        const record = findRun(this.options.root(), runId)
-        const automatic = record && this.options.automatic && standing !== 'none' ? await this.options.automatic(record, input.target, input.operation, standing).catch(() => null) : null
-        if (finished) return 'denied'
-        if (this.nativeCleared.delete(approvalId)) return 'native'
-        if (automatic) {
-          // Marked on the request too, so nothing treats it as waiting on someone.
-          emit('approval.requested', { approvalId, ...payload, automatic })
-          emit('approval.resolved', { approvalId, decision: 'approved', automatic })
-          return 'approved'
-        }
-        emit('approval.requested', { approvalId, ...payload })
-        emit('status.changed', { status: 'waiting_for_approval' })
-        return new Promise<ApprovalDecision>((resolve) => {
-          const timer = timeoutMs ? setTimeout(() => this.approvals.get(approvalId)?.resolve('denied'), timeoutMs) : null
-          this.approvals.set(approvalId, {
-            runId,
-            resolve: (decision) => {
-              if (timer) clearTimeout(timer)
-              this.approvals.delete(approvalId)
-              emit('approval.resolved', { approvalId, decision })
-              emit('status.changed', { status: waitingStatus() })
-              resolve(decision)
-            }
-          })
-        })
-      },
-      requestAnswer: (input) => requestQuestion(input),
-      requestAnswers: (inputs) => {
-        if (!Array.isArray(inputs) || inputs.length < 1 || inputs.length > 5) {
-          throw new HarnessError('invalid_request', 'A question batch must contain between one and five questions.')
-        }
-        const requestedIds = inputs.flatMap((input) => input.requestId ? [input.requestId] : [])
-        if (new Set(requestedIds).size !== requestedIds.length || requestedIds.some((id) => this.questions.has(id))) {
-          throw new HarnessError('invalid_request', 'Question ids in a batch must be unique and not already pending.')
-        }
-        if (finished) return Promise.resolve(inputs.map(() => ({ selected: [] })))
-        const batchId = randomUUID()
-        const answers = inputs.map((input, index) => requestQuestion(input, { batchId, batchIndex: index + 1, batchCount: inputs.length }, false))
-        emit('status.changed', { status: 'waiting_for_input' })
-        return Promise.all(answers)
-      },
-      finish: (outcome, failure) => {
-        if (finished) return
-        if (outcome === 'failed') emit('failed', failure ?? { code: 'failed', message: 'The run failed.' })
-        else if (outcome === 'interrupted') emit('status.changed', { status: 'interrupted' })
-        else emit('completed', {})
-        finished = true
-        this.runs.delete(runId)
-        for (const [id, owner] of this.nativeCleared) if (owner === runId) this.nativeCleared.delete(id)
-        for (const [, approval] of [...this.approvals]) if (approval.runId === runId) approval.resolve('denied')
-        for (const [, question] of [...this.questions]) if (question.runId === runId) question.resolve({ selected: [] })
-        try {
-          this.options.ended?.(runId, sessionId)
-        } catch (error) {
-          log('a run could not be closed cleanly', error instanceof Error ? error.message : String(error))
-        }
-      },
-      get finished() {
-        return finished
-      },
-      interrupt: async () => {
-        for (const handler of interruptHandlers) {
-          try {
-            await handler()
-          } catch (error) {
-            log(`an interrupt handler failed for run ${runId}`, error instanceof Error ? error.message : String(error))
-          }
-        }
-        run.finish('interrupted')
-      }
-    }
-
-    this.runs.set(runId, run)
-    emit('started', {})
-    emit('status.changed', { status: 'running' })
-    const record = findRun(this.options.root(), runId)
-    if (record?.parentRunId && this.hasStoppedAncestor(record.parentRunId)) run.finish('interrupted')
-    return run
-  }
-
-  private hasStoppedAncestor(runId: string): boolean {
-    const visited = new Set<string>()
-    let currentId: string | null = runId
-    while (currentId && !visited.has(currentId)) {
-      if (this.stopping.has(currentId)) return true
-      visited.add(currentId)
-      const record = findRun(this.options.root(), currentId)
-      if (!record) return false
-      if (!isActiveStatus(record.status)) return true
-      currentId = record.parentRunId
-    }
-    return false
-  }
-
-  /** The live run with this id, for a tool or broker that reports into it. */
-  active(runId: string): ActiveRun | null {
-    return this.runs.get(runId) ?? null
-  }
-
-  /** The live run of a session, when it has one. */
-  activeForSession(sessionId: string): ActiveRun | null {
-    for (const run of this.runs.values()) if (run.sessionId === sessionId) return run
-    return null
-  }
-
-  /** Hands a message to a live run's model after its current step. Throws `run_not_active` when the run cannot take it. */
-  async steer(runId: string, text: string): Promise<void> {
-    const run = this.runs.get(runId)
-    if (!run) throw new HarnessError('run_not_active', 'This run is not active.')
-    await run.steer(text)
-  }
-
-  async interrupt(runId: string): Promise<void> {
-    const run = this.runs.get(runId)
-    if (!run) throw new HarnessError('run_not_active', 'This run is not active.')
-    if (this.stopping.has(runId)) return
-    const family = runFamily(this.options.root(), runId)
-    const active = family.runs.map(({ run: member }) => member.id).filter((id) => this.runs.has(id))
-    for (const id of active) this.stopping.add(id)
-    try {
-      await Promise.allSettled(active.map((id) => this.runs.get(id)?.interrupt()))
-    } finally {
-      for (const id of active) this.stopping.delete(id)
-    }
-  }
-
-  /** Interrupts every live run, giving each a moment to stop cleanly. */
-  async interruptAll(timeoutMs = 3000): Promise<void> {
-    await Promise.race([Promise.allSettled(this.activeRunIds().map((id) => this.interrupt(id))), new Promise((resolve) => setTimeout(resolve, timeoutMs))])
-  }
-
-  resolveApproval(runId: string, approvalId: string, decision: ApprovalDecision): void {
-    if (decision !== 'approved' && decision !== 'denied' && decision !== 'native') throw new HarnessError('invalid_request', 'Unknown decision.')
-    const approval = this.approvals.get(approvalId)
-    if (!approval || approval.runId !== runId) throw new HarnessError('approval_not_pending', 'This approval is not pending for this run.')
-    approval.resolve(decision)
-  }
-
-  answerQuestion(runId: string, questionId: string, answer: QuestionAnswer): void {
-    const question = this.questions.get(questionId)
-    if (!question || question.runId !== runId) throw new HarnessError('question_not_pending', 'This question is not waiting for an answer.')
-    if (question.batch) throw new HarnessError('question_batch_required', 'Answer every question in this batch together.')
-    question.resolve(this.validateAnswer(question.input, answer))
-  }
-
-  answerQuestions(runId: string, batchId: string, answers: Array<{ questionId: string; answer: QuestionAnswer }>): void {
-    const questions = [...this.questions.entries()].filter(([, pending]) => pending.runId === runId && pending.batch?.batchId === batchId)
-    if (!questions.length || answers.length !== questions.length || new Set(answers.map(({ questionId }) => questionId)).size !== answers.length) {
-      throw new HarnessError('question_not_pending', 'This question batch is not waiting for an answer.')
-    }
-    const pendingById = new Map(questions)
-    const validated = answers.map(({ questionId, answer }) => {
-      const pending = pendingById.get(questionId)
-      if (!pending) throw new HarnessError('question_not_pending', 'Every question in the batch must be answered together.')
-      return { pending, answer: this.validateAnswer(pending.input, answer) }
-    })
-    for (const { pending, answer } of validated) pending.resolve(answer)
-  }
-
-  private validateAnswer(input: QuestionInput, answer: QuestionAnswer): QuestionAnswer {
-    const selected = answer.selected
-    const selectedLabels = new Set(selected)
-    const notes: Record<string, string> = {}
-    for (const [label, note] of Object.entries(answer.notes ?? {})) {
-      const normalized = typeof note === 'string' ? note.trim() : ''
-      if (normalized) notes[label] = normalized
-    }
-    const text = answer.text?.trim()
-    if (
-      (!input.multiSelect && selected.length > 1) ||
-      selectedLabels.size !== selected.length ||
-      selected.some((label) => !input.options.some((option) => option.label === label)) ||
-      (text && !input.allowText) ||
-      Object.keys(notes).some((label) => !selectedLabels.has(label)) ||
-      Object.values(notes).some((note) => note.length > 10_000)
-    ) {
-      throw new HarnessError('invalid_answer', 'Choose the offered options or an allowed text answer, and attach notes only to selected choices.')
-    }
-    return { selected, ...(text ? { text } : {}), ...(Object.keys(notes).length ? { notes } : {}) }
-  }
-
-  activeRunIds(): string[] {
-    return [...this.runs.keys()]
-  }
-
-  /** A request the session's own interface already settled: nothing here is waiting on it any more. */
-  nativeResolved(runId: string, requestId: string): void {
-    if (!this.runs.has(runId)) return
-    const approval = this.approvals.get(requestId)
-    if (approval?.runId === runId) return approval.resolve('native')
-    const question = this.questions.get(requestId)
-    if (question?.runId === runId) return question.resolve({ selected: [] })
-    this.nativeCleared.set(requestId, runId)
-  }
-}

package/src/sessions/runIndex.ts

@@ -1,99 +0,0 @@
-// Run metadata in the index: which runs a session, an agent, or an account has, without
-// reading every run folder.
-import type { DatabaseSync } from 'node:sqlite'
-import { join } from 'node:path'
-
-import { readJson } from '../core/fs'
-import { all, run as execute, runFolders, transaction, withIndex } from '../core/index'
-import { runRecordSchema, type RunRecord } from './contracts'
-
-export function upsertRun(database: DatabaseSync, record: RunRecord): void {
-  execute(
-    database,
-    `INSERT OR REPLACE INTO runs (id, project_id, mode, harness, session_type, session_id, status, started_at, ended_at, account_id, agent_id)
-     VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)`,
-    record.id,
-    record.projectId,
-    record.mode,
-    record.harness,
-    record.sessionType,
-    record.sessionId,
-    record.status,
-    record.startedAt,
-    record.endedAt,
-    record.accountId,
-    record.agentId
-  )
-}
-
-/** Index failures never block a run. */
-export function recordRun(root: string, record: RunRecord): void {
-  try {
-    withIndex(root, (database) => upsertRun(database, record))
-  } catch {
-    // The index is rebuilt from run files when it is next repaired.
-  }
-}
-
-/** Every readable run record under `<data root>/runs`. */
-export function readAllRuns(root: string): RunRecord[] {
-  const records: RunRecord[] = []
-  for (const name of runFolders(root)) {
-    try {
-      const parsed = runRecordSchema.safeParse(readJson(join(root, 'runs', name, 'run.json')))
-      if (parsed.success) records.push(parsed.data)
-    } catch {
-      // Not a run folder.
-    }
-  }
-  return records
-}
-
-/**
- * Adds the runs the table is missing, and those whose status changed, from the run files. A run
- * recorded while the index was unavailable would otherwise be absent from session history.
- */
-export function syncRuns(root: string): number {
-  const known = new Map<string, { status: string | null; agentId: string | null }>()
-  withIndex(root, (database) => {
-    for (const row of all<{ id: string; status: string | null; agent_id: string | null }>(database, 'SELECT id, status, agent_id FROM runs')) known.set(row.id, { status: row.status, agentId: row.agent_id })
-  })
-  // A row is rewritten when its status changed, or when it predates the agent column.
-  const pending = readAllRuns(root).filter((record) => {
-    const row = known.get(record.id)
-    return !row || row.status !== record.status || (row.agentId === null && record.agentId !== null)
-  })
-  if (!pending.length) return 0
-  withIndex(root, (database) => transaction(database, () => pending.forEach((record) => upsertRun(database, record))))
-  return pending.length
-}
-
-export function runsForSession(root: string, sessionId: string, limit: number): string[] {
-  return withIndex(root, (database) => all<{ id: string }>(database, 'SELECT id FROM runs WHERE session_id = ?1 ORDER BY started_at DESC LIMIT ?2', sessionId, limit).map((row) => row.id))
-}
-
-/** Which runs to read: one session's, one agent's wherever it replied, one account's, or all. */
-export interface RunFilter {
-  session?: string | null
-  agent?: string | null
-  account?: string | null
-}
-
-/** Runs matching `filter` started at or after `since` (an RFC 3339 instant), oldest first. */
-export function runsSince(root: string, filter: RunFilter, since: string | null): string[] {
-  return withIndex(root, (database) =>
-    // A chat run recorded before the agent column belongs to the agent whose own session it ran in.
-    all<{ id: string }>(
-      database,
-      `SELECT id FROM runs WHERE started_at >= ?1
-          AND (?2 IS NULL OR session_id = ?2)
-          AND (?3 IS NULL OR agent_id = ?3 OR (agent_id IS NULL AND mode = 'chat' AND session_id = ?3))
-          AND (?4 IS NULL OR account_id = ?4)
-       ORDER BY started_at`,
-      since ?? '',
-      filter.session ?? null,
-      filter.agent ?? null,
-      filter.account ?? null
-    ).map((row) => row.id)
-  )
-}