@xingular/harness 0.1.6 → 2.0.0

package/src/terminal/trajectory.test.ts

@@ -0,0 +1,66 @@
+import { mkdtempSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, expect, it } from 'vitest'
+
+import { closeIndex } from '../core/index'
+import type { RunEvent, RunRecord } from '../sessions/contracts'
+import { appendEvent, saveRun } from '../sessions/runStore'
+import { listTerminalTrajectoryRuns, readTerminalTrajectory } from './trajectory'
+
+const roots: string[] = []
+afterEach(() => {
+  for (const root of roots.splice(0)) closeIndex(root)
+})
+
+function setup() {
+  const root = mkdtempSync(join(tmpdir(), 'harness-terminal-trajectory-'))
+  roots.push(root)
+  const run = (id: string, sessionId: string, nativeSessionId: string | null): RunRecord => ({
+    id, sessionId, nativeSessionId, mode: 'code', goal: id,
+    resumedFromRunId: null, parentRunId: null, relation: null, terminalReason: null,
+    projectId: null, harness: 'pi', sessionType: 'terminal', workingDirectory: '/project',
+    worktreeId: null, attachmentCount: 0, startedAt: `2026-10-18T00:00:0${id.slice(-1)}Z`,
+    endedAt: null, status: 'running', exitCode: null, handoffId: null,
+    accountId: 'account-1', agentId: null, trigger: null
+  })
+  return { root, run }
+}
+
+const event = (runId: string, sessionId: string, sequence: number): RunEvent => ({
+  id: `${runId}-event-${sequence}`, runId, sessionId, sequence,
+  timestamp: `2026-10-18T00:00:0${sequence}Z`, type: 'started', payload: {}
+})
+
+it('lists newest runs only for the current terminal session and native conversation', () => {
+  const { root, run } = setup()
+  for (const item of [
+    run('run-1', 'terminal-1', '/history/one.jsonl'),
+    run('run-2', 'terminal-1', '/history/two.jsonl'),
+    run('run-3', 'terminal-2', '/history/one.jsonl')
+  ]) saveRun(root, item)
+
+  expect(listTerminalTrajectoryRuns(root, 'terminal-1', '/history/one.jsonl').map(item => item.id)).toEqual(['run-1'])
+  expect(listTerminalTrajectoryRuns(root, 'terminal-1', null)).toEqual([])
+})
+
+it('reads a selected run and only returns events after the requested sequence', () => {
+  const { root, run } = setup()
+  saveRun(root, run('run-1', 'terminal-1', '/history/current.jsonl'))
+  appendEvent(root, event('run-1', 'terminal-1', 0))
+  appendEvent(root, event('run-1', 'terminal-1', 1))
+
+  expect(readTerminalTrajectory(root, 'terminal-1', '/history/current.jsonl', 'run-1', 0)).toMatchObject({
+    run: { id: 'run-1', goal: 'run-1' },
+    events: [{ sequence: 1 }]
+  })
+})
+
+it('does not reveal runs from a different terminal or native conversation', () => {
+  const { root, run } = setup()
+  saveRun(root, run('run-1', 'terminal-1', '/history/one.jsonl'))
+
+  expect(() => readTerminalTrajectory(root, 'terminal-2', '/history/one.jsonl', 'run-1')).toThrow('Run was not found')
+  expect(() => readTerminalTrajectory(root, 'terminal-1', '/history/two.jsonl', 'run-1')).toThrow('Run was not found')
+  expect(() => readTerminalTrajectory(root, 'terminal-1', '/history/one.jsonl', 'run-1', -1)).toThrow('Run was not found')
+})

package/src/terminal/trajectory.ts

@@ -0,0 +1,44 @@
+import { notFound } from '../core/errors'
+import type { RunEvent, RunRecord } from '../sessions/contracts'
+import { findRun, listRuns, readEvents } from '../sessions/runStore'
+
+export type TerminalTrajectoryRun = Pick<RunRecord, 'id' | 'mode' | 'goal' | 'startedAt' | 'endedAt' | 'status'>
+
+export interface TerminalTrajectorySnapshot {
+  run: TerminalTrajectoryRun
+  events: RunEvent[]
+}
+
+function summary(run: RunRecord): TerminalTrajectoryRun {
+  return {
+    id: run.id,
+    mode: run.mode,
+    goal: run.goal,
+    startedAt: run.startedAt,
+    endedAt: run.endedAt,
+    status: run.status
+  }
+}
+
+/** The native conversation file is the terminal's boundary for this read-only view. */
+export function listTerminalTrajectoryRuns(root: string, sessionId: string, nativeSessionId: string | null): TerminalTrajectoryRun[] {
+  if (!nativeSessionId) return []
+  return listRuns(root, { sessionId })
+    .filter(run => run.nativeSessionId === nativeSessionId)
+    .map(summary)
+}
+
+/** Read a run only when it belongs to both this terminal and its current native conversation. */
+export function readTerminalTrajectory(
+  root: string,
+  sessionId: string,
+  nativeSessionId: string | null,
+  runId: string,
+  afterSequence?: number
+): TerminalTrajectorySnapshot {
+  if (!nativeSessionId || !Number.isSafeInteger(afterSequence ?? 0) || (afterSequence ?? 0) < 0) throw notFound('Run')
+  const run = findRun(root, runId)
+  if (!run || run.sessionId !== sessionId || run.nativeSessionId !== nativeSessionId) throw notFound('Run')
+  const events = readEvents(root, runId).filter(event => afterSequence === undefined || event.sequence > afterSequence)
+  return { run: summary(run), events }
+}

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

@@ -0,0 +1,290 @@
+import { CustomEditor, type AgentSessionEvent, type ExtensionUIContext, type Theme } from '@earendil-works/pi-coding-agent'
+import { stripTerminalSequences } from '@earendil-works/pi-tui'
+import { describe, expect, it, vi } from 'vitest'
+
+vi.mock('../control', () => ({ controlCall: vi.fn(async () => ({})) }))
+import { controlCall } from '../control'
+import { TerminalApplication } from './application'
+import type { TerminalDecision } from './runtime'
+import { terminalKeybindings } from './keybindings'
+import { autocompleteRuleColor, createHarnessTheme } from './theme'
+import { TerminalTranscript } from './transcript'
+
+function setup() {
+  const application = new TerminalApplication([])
+  const app = application as unknown as {
+    theme: Theme
+    ui: ExtensionUIContext & {
+      wrapAutocomplete<T>(value: T): T
+      dispose(): void
+      state: { workingVisible: boolean; workingMessage?: string; workingIndicator?: { frames?: string[]; intervalMs?: number } }
+    }
+    keybindings: ReturnType<typeof terminalKeybindings>
+    editor: CustomEditor
+    runtime: { interrupt: ReturnType<typeof vi.fn>; dispose: ReturnType<typeof vi.fn>; session: object; snapshot(): { hasUserMessages: boolean; cwd?: string; model?: { name: string; reasoning: boolean; contextWindow: number }; thinkingLevel?: string; account?: { label: string } | null; context?: { percent: number | null; window: number }; costUsd?: number; subscription?: boolean } }
+    commands: { execute: ReturnType<typeof vi.fn> }
+    masthead: { render(width: number): string[] }
+    header?: { render(width: number): string[]; invalidate(): void }
+    branch: string | null
+    transcript: TerminalTranscript
+    initialized: boolean
+    commandBusy: boolean
+    mountEditor(factory?: Parameters<ExtensionUIContext['setEditorComponent']>[0]): void
+    dispatchInput(data: string): { consume?: boolean } | undefined
+    submit(text: string): void
+    accept(event: AgentSessionEvent): void
+    band(width: number): string
+    titleLines(width: number): string[]
+    resetWorkingStatus(): void
+    phase?: string
+  }
+  vi.spyOn(application.tui, 'requestRender').mockImplementation(() => {})
+  vi.spyOn(application.tui, 'stop').mockImplementation(() => {})
+  vi.spyOn(application.terminal, 'drainInput').mockResolvedValue()
+  vi.spyOn(application.terminal, 'setProgress').mockImplementation(() => {})
+  const ui = { theme: createHarnessTheme({ getColorMode: () => 'truecolor' } as Theme), state: { workingVisible: true }, wrapAutocomplete: <T>(value: T) => value,
+    setToolsExpanded: vi.fn(), dispose: vi.fn() } as unknown as typeof app.ui
+  app.ui = ui
+  app.transcript = new TerminalTranscript(application.tui, () => ui.theme, () => undefined)
+  app.keybindings = terminalKeybindings('/unused/isolated-account')
+  app.initialized = true
+  const context = {}
+  app.runtime = { interrupt: vi.fn(async () => {}), dispose: vi.fn(async () => {}), snapshot: () => ({
+    hasUserMessages: false, cwd: '/work/project', model: { name: 'Claude Sonnet 4.6', reasoning: true, contextWindow: 200_000 },
+    thinkingLevel: 'high', account: { label: 'Tanny' }, context: { percent: null, window: 0 }, costUsd: 0, subscription: false
+  }), session: {
+    extensionRunner: { getShortcuts: () => new Map(), createContext: () => context },
+    state: { messages: [] }, settingsManager: { getShowTerminalProgress: () => false },
+    getSessionStats: () => ({ tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } })
+  } }
+  return { application, app, ui }
+}
+
+describe('the owned terminal application', () => {
+  it('shows a stable animated verb, then keeps completion status until the next turn', async () => {
+    const { application, app } = setup()
+    let now = 1000
+    const dateNow = vi.spyOn(Date, 'now').mockImplementation(() => now)
+    const random = vi.spyOn(Math, 'random').mockReturnValue(0)
+
+    app.accept({ type: 'agent_start' } as AgentSessionEvent)
+    const initialStatus = app.titleLines(100)[0] ?? ''
+    expect(initialStatus).toContain(app.theme.fg('warning', '· Accomplishing'))
+    const orangeRgb = autocompleteRuleColor(app.theme).slice(1).match(/.{2}/g)?.map(value => Number.parseInt(value, 16)) ?? []
+    expect(initialStatus).toContain(`38;2;${orangeRgb.join(';')}`)
+    expect(stripTerminalSequences(initialStatus).trim()).toContain('· Accomplishing')
+    now = 1080
+    const nextFrameStatus = app.titleLines(100)[0] ?? ''
+    expect(nextFrameStatus).toContain(app.theme.fg('warning', '✢ Accomplishing'))
+    expect(stripTerminalSequences(nextFrameStatus).trim()).toContain('✢ Accomplishing')
+
+    now = 2450
+    app.accept({ type: 'agent_settled' } as AgentSessionEvent)
+    const completed = stripTerminalSequences(app.titleLines(100)[0] ?? '').trim()
+    expect(completed).toMatch(/^✻ (Baked|Brewed|Churned|Cogitated|Cooked|Crunched|Sautéed|Worked) for 1s$/)
+    expect(stripTerminalSequences(app.titleLines(100)[0] ?? '').trim()).toBe(completed)
+
+    now = 3000
+    app.accept({ type: 'agent_start' } as AgentSessionEvent)
+    expect(stripTerminalSequences(app.titleLines(100)[0] ?? '').trim()).toContain('· Accomplishing')
+    app.resetWorkingStatus()
+    expect(app.titleLines(100)).toEqual([])
+
+    random.mockRestore()
+    dateNow.mockRestore()
+    await application.shutdown()
+  })
+
+  it('keeps extension working overrides and phase labels ahead of the default verb', async () => {
+    const { application, app, ui } = setup()
+    ui.state.workingMessage = 'Inspecting'
+    ui.state.workingIndicator = { frames: ['●'], intervalMs: 500 }
+
+    app.accept({ type: 'agent_start' } as AgentSessionEvent)
+    expect(stripTerminalSequences(app.titleLines(100)[0] ?? '').trim()).toContain('● Inspecting')
+    app.accept({ type: 'compaction_start' } as AgentSessionEvent)
+    expect(stripTerminalSequences(app.titleLines(100)[0] ?? '').trim()).toContain('● Compacting context…')
+    ui.state.workingVisible = false
+    expect(stripTerminalSequences(app.titleLines(100)[0] ?? '').trim()).toContain('● Compacting context…')
+    app.phase = undefined
+    expect(app.titleLines(100)).toEqual([])
+
+    await application.shutdown()
+  })
+
+  it('shows current-conversation input plus cache-read totals and the last completed response rate', async () => {
+    const { application, app } = setup()
+    app.branch = 'main'
+    Object.assign(app.runtime.session, { getSessionStats: () => ({ tokens: { input: 1200, output: 540, cacheRead: 300, cacheWrite: 100 } }) })
+    const now = vi.spyOn(performance, 'now').mockReturnValueOnce(1000).mockReturnValueOnce(3000).mockReturnValueOnce(4000).mockReturnValueOnce(6000)
+    app.accept({ type: 'turn_start' } as AgentSessionEvent)
+    expect(stripTerminalSequences(app.band(160))).toContain('— tok/s in 1,500 out 540')
+    app.accept({ type: 'message_end', message: { role: 'assistant', content: [], usage: { output: 60 } } } as unknown as AgentSessionEvent)
+    expect(stripTerminalSequences(app.band(160))).toBe('project | main | Tanny · Sonnet 4.6 · high | 30 tok/s in 1,500 out 540')
+    app.accept({ type: 'turn_start' } as AgentSessionEvent)
+    expect(stripTerminalSequences(app.band(160))).toContain('30 tok/s in 1,500 out 540')
+    app.accept({ type: 'message_end', message: { role: 'assistant', content: [], usage: { output: 40 } } } as unknown as AgentSessionEvent)
+    expect(stripTerminalSequences(app.band(160))).toContain('20 tok/s in 1,500 out 540')
+    now.mockRestore()
+    await application.shutdown()
+  })
+
+  it('lets trusted custom editor modes consume Escape before delegating host actions', async () => {
+    const { application, app } = setup()
+    let normalMode = false
+    class ModalEditor extends CustomEditor {
+      override handleInput(data: string) {
+        if (data === '\x1b') { normalMode = true; return }
+        super.handleInput(data)
+      }
+    }
+    app.mountEditor((tui, theme, keys) => new ModalEditor(tui, theme, keys))
+    expect(app.dispatchInput('\x1b')).toBeUndefined()
+    app.editor.handleInput('\x1b')
+    expect(normalMode).toBe(true)
+    expect(app.runtime.interrupt).not.toHaveBeenCalled()
+    expect(app.dispatchInput('\x0f')).toBeUndefined()
+    app.editor.handleInput('\x0f')
+    expect(app.ui.setToolsExpanded).toHaveBeenCalledWith(true)
+    await application.shutdown()
+  })
+
+  it('preserves custom editor change callbacks and reports actual draft contents', async () => {
+    const { application, app } = setup()
+    const changed = vi.fn()
+    app.mountEditor((tui, theme, keys) => { const editor = new CustomEditor(tui, theme, keys); editor.onChange = changed; return editor })
+    app.dispatchInput('draft')
+    app.editor.handleInput('draft')
+    await vi.waitFor(() => expect(controlCall).toHaveBeenCalledWith('terminal.draft', { dirty: true }))
+    expect(changed).toHaveBeenCalledWith('draft')
+    expect(app.editor.getText()).toBe('draft')
+    await application.shutdown()
+  })
+
+  it('opens the keyboard list on ? over an empty prompt, and types ? into a draft', async () => {
+    const { application, app } = setup()
+    app.mountEditor()
+    expect(app.dispatchInput('?')).toEqual({ consume: true })
+    expect(app.editor.getText()).toBe('')
+    expect(app.transcript.render(120).join('\n')).toContain('PgUp/PgDn: scroll transcript')
+    app.editor.setText('draft')
+    expect(app.dispatchInput('?')).toBeUndefined()
+    await application.shutdown()
+  })
+
+  it('offers Allow once, a tool-wide grant only when eligible, and Deny in the approval prompt', async () => {
+    const { application, app } = setup()
+    let shown = ''
+    let chooseGlobal = true
+    const ui = app.ui as unknown as { custom: (factory: (...args: unknown[]) => unknown) => Promise<string | undefined> }
+    ui.custom = factory => new Promise(resolve => {
+      const panel = factory(application.tui, app.ui.theme, app.keybindings, (value: unknown) => resolve(typeof value === 'string' ? value : undefined)) as {
+        handleInput(data: string): void
+        render(width: number): string[]
+      }
+      shown = stripTerminalSequences(panel.render(100).join('\n'))
+      if (chooseGlobal) panel.handleInput('\x1b[B')
+      panel.handleInput('\r')
+    })
+    const choose = (application as unknown as { chooseApproval(request: TerminalDecision, signal: AbortSignal): Promise<{ decision: string; alwaysAllow: boolean }> }).chooseApproval.bind(application)
+    const remembered = await choose({ type: 'approval', requestId: 'r1', target: 'bash', rememberable: true, action: '{"command":"git status"}' } as TerminalDecision, new AbortController().signal)
+    expect(shown).toContain('Always allow bash everywhere')
+    expect(shown).toContain('Allow once')
+    expect(shown).toContain('Deny')
+    expect(remembered).toEqual({ decision: 'approved', alwaysAllow: true })
+
+    chooseGlobal = false
+    const oneTime = await choose({ type: 'approval', requestId: 'r2', target: 'bash', rememberable: false, action: '{}' } as TerminalDecision, new AbortController().signal)
+    expect(shown).not.toContain('Always allow bash everywhere')
+    expect(oneTime).toEqual({ decision: 'approved', alwaysAllow: false })
+    await application.shutdown()
+  })
+
+  it('hides the product lockup once the chat has a user message', async () => {
+    const { application, app } = setup()
+    expect(app.masthead.render(80).join('\n')).toContain('Xingular Harness')
+    app.runtime.snapshot = () => ({ hasUserMessages: true })
+    expect(app.masthead.render(80)).toEqual([])
+    app.runtime.snapshot = () => ({ hasUserMessages: false })
+    expect(app.masthead.render(80).join('\n')).toContain('Xingular Harness')
+    await application.shutdown()
+  })
+
+  it('keeps an extension header after the chat starts', async () => {
+    const { application, app } = setup()
+    vi.spyOn(application.terminal, 'write').mockImplementation(() => {})
+    app.header = { render: () => ['custom header'], invalidate: () => {} }
+    app.runtime.snapshot = () => ({ hasUserMessages: true })
+    expect(app.masthead.render(80)).toContain('custom header')
+    await application.shutdown()
+  })
+
+  it('routes leading-space commands and serializes command dialogs', async () => {
+    const { application, app } = setup()
+    app.mountEditor()
+    let resolve!: (value: boolean) => void
+    app.commands = { execute: vi.fn(() => new Promise<boolean>(done => { resolve = done })) }
+    app.submit('   /settings')
+    await vi.waitFor(() => expect(app.commands.execute).toHaveBeenCalledWith('   /settings'))
+    app.submit('/model')
+    await Promise.resolve(); await Promise.resolve()
+    expect(app.commands.execute).toHaveBeenCalledTimes(1)
+    resolve(true)
+    await vi.waitFor(() => expect(app.commandBusy).toBe(false))
+    await application.shutdown()
+  })
+
+  it('toggles plan mode on Shift+Tab, narrowing to read-only tools and leaving thinking alone', async () => {
+    const { application, app } = setup()
+    const session = app.runtime.session as { getActiveToolNames(): string[]; setActiveToolsByName(names: string[]): void; cycleThinkingLevel(): void }
+    const setActiveToolsByName = vi.fn()
+    const cycleThinkingLevel = vi.fn()
+    Object.assign(session, { getActiveToolNames: () => ['read', 'bash', 'edit', 'write', 'grep', 'spawn_subagent'], setActiveToolsByName, cycleThinkingLevel })
+    expect(app.dispatchInput('\x1b[Z')).toEqual({ consume: true })
+    expect(setActiveToolsByName).toHaveBeenLastCalledWith(['read', 'grep'])
+    expect(app.dispatchInput('\x1b[Z')).toEqual({ consume: true })
+    expect(setActiveToolsByName).toHaveBeenLastCalledWith(['read', 'bash', 'edit', 'write', 'grep', 'spawn_subagent'])
+    expect(cycleThinkingLevel).not.toHaveBeenCalled()
+    await application.shutdown()
+  })
+
+  it('steps thinking effort with shift arrows and stops at the ends of the model levels', async () => {
+    const { application, app } = setup()
+    const session = app.runtime.session as { thinkingLevel: string; getAvailableThinkingLevels(): string[]; supportsThinking(): boolean; setThinkingLevel(level: string): void }
+    const setThinkingLevel = vi.fn((level: string) => { session.thinkingLevel = level })
+    Object.assign(session, { thinkingLevel: 'low', getAvailableThinkingLevels: () => ['off', 'minimal', 'low', 'medium', 'high'], supportsThinking: () => true, setThinkingLevel })
+    expect(app.dispatchInput('\x1b[1;2A')).toEqual({ consume: true })
+    expect(app.dispatchInput('\x1b[1;2A')).toEqual({ consume: true })
+    expect(app.dispatchInput('\x1b[1;2A')).toEqual({ consume: true })
+    expect(setThinkingLevel.mock.calls).toEqual([['medium'], ['high']])
+    expect(app.dispatchInput('\x1b[1;2B')).toEqual({ consume: true })
+    expect(setThinkingLevel).toHaveBeenLastCalledWith('medium')
+    await application.shutdown()
+  })
+
+  it('restores terminal modes and finishes even when runtime and plugin cleanup fail', async () => {
+    const { application, app } = setup()
+    const header = { dispose: vi.fn(() => { throw new Error('header cleanup failed') }) }
+    const footer = { dispose: vi.fn() }
+    Object.assign(app, { header, footer })
+    app.ui.dispose = vi.fn(() => { throw new Error('dialog cleanup failed') })
+    app.runtime.dispose.mockRejectedValue(new Error('runtime cleanup failed'))
+    await expect(application.shutdown()).resolves.toBeUndefined()
+    expect(header.dispose).toHaveBeenCalledOnce()
+    expect(footer.dispose).toHaveBeenCalledOnce()
+    expect(app.runtime.dispose).toHaveBeenCalledOnce()
+    expect(application.terminal.drainInput).toHaveBeenCalledOnce()
+    expect(application.tui.stop).toHaveBeenCalledOnce()
+  })
+
+  it('has one shutdown that disposes the runtime and restores the terminal', async () => {
+    const { application, app } = setup()
+    const first = application.shutdown()
+    expect(application.shutdown()).toBe(first)
+    await first
+    expect(app.ui.dispose).toHaveBeenCalledOnce()
+    expect(app.runtime.dispose).toHaveBeenCalledOnce()
+    expect(application.terminal.drainInput).toHaveBeenCalledOnce()
+    expect(application.tui.stop).toHaveBeenCalledOnce()
+  })
+})