@xingular/harness 0.0.0-stage → 0.1.0

package/src/sessions/reasoningSummaries.ts

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

@@ -0,0 +1,294 @@
+// 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
+  question: string
+  options: QuestionOption[]
+  multiSelect: boolean
+  allowText: boolean
+}
+
+export interface QuestionAnswer {
+  selected: string[]
+  text?: string
+}
+
+export interface ActiveRun {
+  runId: string
+  sessionId: string
+  emit(type: RunEventType, payload: unknown, native?: unknown): void
+  onInterrupt(handler: () => 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>
+  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> }
+
+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, { runId: string; input: QuestionInput; resolve: (answer: QuestionAnswer) => void }>()
+  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> = []
+    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 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),
+      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) => {
+        const { requestId, ...payload } = input
+        const questionId = requestId ?? randomUUID()
+        if (finished || this.nativeCleared.delete(questionId)) return Promise.resolve({ selected: [] })
+        emit('question.requested', { questionId, ...payload })
+        emit('status.changed', { status: 'waiting_for_input' })
+        return new Promise<QuestionAnswer>((resolve) => {
+          this.questions.set(questionId, {
+            runId,
+            input,
+            resolve: (answer) => {
+              this.questions.delete(questionId)
+              emit('question.answered', { questionId, ...answer })
+              emit('status.changed', { status: waitingStatus() })
+              resolve(answer)
+            }
+          })
+        })
+      },
+      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
+  }
+
+  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.input.multiSelect && answer.selected.length > 1) || answer.selected.some((label) => !question.input.options.some((option) => option.label === label)) || (answer.text && !question.input.allowText)) {
+      throw new HarnessError('invalid_answer', 'Choose the offered options or an allowed text answer.')
+    }
+    question.resolve(answer)
+  }
+
+  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

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

package/src/sessions/runStore.test.ts

@@ -0,0 +1,152 @@
+import { appendFileSync, mkdtempSync, readFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { expect, test } from 'vitest'
+
+import { now } from '../core/fs'
+import { closeIndex } from '../core/index'
+import { isActiveStatus, runEventPayloadSchemas, runRecordSchema, type RunEvent, type RunEventType } from './contracts'
+import { appendEvent, executionEvents, loadRun, markInterruptedRuns, pendingDecisions, persistEvent, readEvents, runDir, saveRun, updateRun } from './runStore'
+
+const temp = () => mkdtempSync(join(tmpdir(), 'harness-runs-'))
+const valid = (type: RunEventType, payload: unknown): boolean => runEventPayloadSchemas[type].safeParse(payload).success
+
+function fixtureRun(root: string, status: string) {
+  const run = runRecordSchema.parse({ id: 'run-1', sessionId: 'agent-1', projectId: null, mode: 'chat', harness: 'pi', sessionType: 'structured', nativeSessionId: null, workingDirectory: null, worktreeId: null, goal: null, status, startedAt: 'start', endedAt: null })
+  saveRun(root, run)
+  return run
+}
+
+const fixtureEvent = (sequence: number, type: string, payload: unknown): RunEvent => ({ id: `e${sequence}`, runId: 'run-1', sessionId: 'agent-1', sequence, timestamp: `time-${sequence}`, type: type as RunEventType, payload })
+
+test('execution prefix includes first terminal and excludes ignored evidence', () => {
+  for (const status of ['completed', 'failed', 'interrupted']) {
+    const ignored = { ...fixtureEvent(1, 'usage.updated', { outputTokens: 99 }), native: { hostIgnored: 'run_already_ended' } }
+    const events = [fixtureEvent(0, 'started', {}), ignored, fixtureEvent(2, 'status.changed', { status }), fixtureEvent(3, 'message.completed', { text: 'late' })]
+    expect(executionEvents(events).map((event) => event.sequence)).toEqual([0, 2])
+  }
+})
+
+test('trajectory evidence event payloads are validated', () => {
+  expect(valid('context.snapshot', { systemPrompt: 'app prompt', contextUpdate: 'changed context', tools: [{ name: 'read', description: 'Read a file', parameters: { type: 'object' } }], contextUpdateTruncated: false })).toBe(true)
+  expect(valid('context.snapshot', { systemPrompt: 'prompt', tools: [{ name: 'read' }] })).toBe(false)
+  expect(valid('tool.started', { toolCallId: 't', name: 'read', input: '{}', inputTruncated: false })).toBe(true)
+  expect(valid('tool.completed', { toolCallId: 't', name: 'read', ok: true, output: 'text', outputTruncated: true })).toBe(true)
+  expect(valid('retry.started', { attempt: 1, maxAttempts: 3, delayMs: 250, error: 'temporary' })).toBe(true)
+  expect(valid('retry.ended', { attempt: 1, success: true })).toBe(true)
+  expect(valid('compaction.started', { reason: 'threshold' })).toBe(true)
+  expect(valid('compaction.ended', { reason: 'threshold', aborted: false, willRetry: true, summary: 'kept recent messages' })).toBe(true)
+  expect(valid('retry.ended', { attempt: 1, success: 'yes' })).toBe(false)
+})
+
+test('pending decisions are the requests nothing answered', () => {
+  const events = [
+    fixtureEvent(0, 'approval.requested', { approvalId: 'a1', target: 'shell', action: 'ls' }),
+    fixtureEvent(1, 'question.requested', { questionId: 'q1', question: 'Which?', options: [], multiSelect: false, allowText: true }),
+    fixtureEvent(2, 'approval.requested', { approvalId: 'a2', target: 'shell', action: 'pwd' }),
+    fixtureEvent(3, 'approval.resolved', { approvalId: 'a1', decision: 'denied' }),
+    // An answer to another kind of request with the same id settles nothing.
+    fixtureEvent(4, 'question.answered', { questionId: 'a2', selected: [] })
+  ]
+  expect(pendingDecisions(events).map((decision) => [decision.kind, decision.id, decision.eventId])).toEqual([['question', 'q1', 'e1'], ['approval', 'a2', 'e2']])
+  expect(valid('approval.requested', { approvalId: 'a3', target: 'shell', action: 'ls', automatic: 'scope' })).toBe(true)
+  expect(valid('approval.resolved', { approvalId: 'a3', decision: 'approved', automatic: 'scope' })).toBe(true)
+  expect(valid('approval.resolved', { approvalId: 'a3', decision: 'approved', automatic: 'whenever' })).toBe(false)
+})
+
+test('interruption is not overwritten by late tools, messages or completion', () => {
+  const root = temp()
+  fixtureRun(root, 'running')
+  expect(persistEvent(root, fixtureEvent(0, 'status.changed', { status: 'interrupted', reason: 'App stopped' }))).toBe(true)
+  const late: [number, string, unknown][] = [
+    [1, 'tool.completed', { toolCallId: 't1', name: 'bash', ok: false }],
+    [2, 'message.completed', { messageId: 'm1', role: 'assistant', text: 'Saved checkpoint' }],
+    [3, 'completed', {}],
+    [4, 'status.changed', { status: 'running' }]
+  ]
+  for (const [index, type, payload] of late) expect(persistEvent(root, fixtureEvent(index, type, payload))).toBe(false)
+  updateRun(root, 'run-1', (run) => {
+    run.status = 'completed'
+    run.nativeSessionId = 'native-1'
+  })
+  const run = loadRun(root, 'run-1')
+  expect([run.status, run.endedAt, run.nativeSessionId, run.terminalReason]).toEqual(['interrupted', 'time-0', 'native-1', 'App stopped'])
+  const events = readEvents(root, 'run-1')
+  expect(events).toHaveLength(5)
+  expect((events[2].payload as { text: string }).text).toBe('Saved checkpoint')
+  expect((events[3].native as { hostIgnored: string }).hostIgnored).toBe('run_already_ended')
+  closeIndex(root)
+})
+
+test('recovery repairs legacy outcomes once without erasing evidence', () => {
+  const root = temp()
+  fixtureRun(root, 'completed')
+  appendEvent(root, fixtureEvent(0, 'status.changed', { status: 'interrupted' }))
+  appendEvent(root, fixtureEvent(1, 'message.completed', { role: 'assistant', messageId: 'm', text: 'Partial answer' }))
+  appendEvent(root, fixtureEvent(2, 'completed', {}))
+  markInterruptedRuns(root)
+  const backup = join(runDir(root, 'run-1'), 'run.json.before-outcome-repair')
+  const original = readFileSync(backup, 'utf8')
+  expect(loadRun(root, 'run-1').status).toBe('interrupted')
+  expect(readEvents(root, 'run-1')).toHaveLength(3)
+  markInterruptedRuns(root)
+  expect(readFileSync(backup, 'utf8')).toBe(original)
+  expect(readEvents(root, 'run-1')).toHaveLength(3)
+  closeIndex(root)
+})
+
+test('a run that never settled is marked interrupted at startup', () => {
+  const root = temp()
+  fixtureRun(root, 'running')
+  appendEvent(root, fixtureEvent(0, 'started', {}))
+  expect(markInterruptedRuns(root)).toBe(1)
+  expect(loadRun(root, 'run-1').status).toBe('interrupted')
+  expect(readEvents(root, 'run-1').at(-1)).toMatchObject({ sequence: 1, type: 'status.changed' })
+  expect(markInterruptedRuns(root)).toBe(0)
+  closeIndex(root)
+})
+
+test('normal completion and failure are terminal too', () => {
+  const cases: [string, string, unknown][] = [['completed', 'completed', {}], ['failed', 'failed', { message: 'No quota', code: 'provider_error' }]]
+  for (const [type, expected, payload] of cases) {
+    const root = temp()
+    fixtureRun(root, 'running')
+    expect(persistEvent(root, fixtureEvent(0, type, payload))).toBe(true)
+    expect(persistEvent(root, fixtureEvent(1, 'status.changed', { status: 'running' }))).toBe(false)
+    expect(loadRun(root, 'run-1').status).toBe(expected)
+    closeIndex(root)
+  }
+})
+
+test('active run filter includes only work in progress', () => {
+  expect(['queued', 'running', 'waiting_for_approval'].every(isActiveStatus)).toBe(true)
+  expect(['completed', 'interrupted', 'failed'].some(isActiveStatus)).toBe(false)
+})
+
+test('validates payloads by type', () => {
+  expect(valid('message.delta', { messageId: 'm', text: 'hi' })).toBe(true)
+  expect(valid('message.delta', { text: 'hi' })).toBe(false)
+  expect(valid('usage.updated', { inputTokens: 3, outputTokens: 1 })).toBe(true)
+  expect(valid('usage.updated', { inputTokens: 3, cacheReadTokens: 9, reasoningTokens: 1, costUsd: 0.02, requests: 2, contextTokens: 12, contextWindow: 1000, model: 'm', provider: 'p' })).toBe(true)
+  expect(valid('usage.updated', { inputTokens: 3, costUsd: '0.02' })).toBe(false)
+  expect(valid('usage.updated', { provider: 4 })).toBe(false)
+  expect(valid('usage.updated', { request: { index: 1, reasoningSummary: 'The provider summary.' } })).toBe(true)
+  expect(valid('usage.updated', { request: { index: 1, reasoningSummary: 'x'.repeat(4_001) } })).toBe(false)
+  expect(valid('approval.resolved', { approvalId: 'a', decision: 'denied' })).toBe(true)
+  expect(valid('approval.resolved', { approvalId: 'a', decision: 'maybe' })).toBe(false)
+  expect(valid('question.requested', { questionId: 'q', question: 'Which?', options: [{ label: 'A' }], multiSelect: false, allowText: true })).toBe(true)
+  expect(valid('question.requested', { questionId: 'q', question: 'Which?', options: [{}], multiSelect: false, allowText: true })).toBe(false)
+  expect(valid('question.answered', { questionId: 'q', selected: ['A'], text: 'also B' })).toBe(true)
+  expect(valid('reaction.added', { emoji: '👍' })).toBe(true)
+  expect(valid('reaction.added', { emoji: 'lol' })).toBe(false)
+  expect(valid('agent.message', { direction: 'to', agentId: 'a', agentName: 'A', text: 'hi' })).toBe(true)
+  expect(valid('status.changed', { status: 'waiting_for_input' })).toBe(true)
+  expect(valid('status.changed', { status: 'done' })).toBe(false)
+})
+
+test('event log skips torn lines', () => {
+  const root = temp()
+  appendEvent(root, { id: 'e', runId: 'run-1', sessionId: 's', sequence: 0, timestamp: now(), type: 'started', payload: {} })
+  appendFileSync(join(runDir(root, 'run-1'), 'events.jsonl'), '{"id":"torn')
+  expect(readEvents(root, 'run-1')).toHaveLength(1)
+})