@xingular/harness 0.1.7 → 2.1.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

@@ -1,44 +1,137 @@
-import { CustomEditor, type ExtensionUIContext, type Theme } from '@earendil-works/pi-coding-agent'
+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 { createTerminalCommands, type TerminalCommandHost } from './commands'
+import type { TerminalDecision } from './runtime'
 import { terminalKeybindings } from './keybindings'
-import { createHarnessTheme } from './theme'
+import { autocompleteRuleColor, createHarnessTheme } from './theme'
+import { TerminalTranscript } from './transcript'
 
 function setup() {
   const application = new TerminalApplication([])
   const app = application as unknown as {
-    ui: ExtensionUIContext & { wrapAutocomplete<T>(value: T): T; dispose(): void }
+    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: unknown }
-    commands: { execute: ReturnType<typeof vi.fn> }
+    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: ReturnType<typeof createTerminalCommands> | { execute: ReturnType<typeof vi.fn> }
+    planMode: boolean
+    setPlanMode(enabled: boolean): void
+    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()
-  const ui = { theme: createHarnessTheme({ getColorMode: () => 'truecolor' } as Theme), wrapAutocomplete: <T>(value: T) => value,
+  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 () => {}), session: {
+  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: {}
+    state: { messages: [] }, settingsManager: { getShowTerminalProgress: () => false },
+    getSessionStats: () => ({ tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } })
   } }
-  application.tui.addChild(application)
   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
@@ -71,6 +164,64 @@ describe('the owned terminal application', () => {
     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()
@@ -86,6 +237,52 @@ describe('the owned terminal application', () => {
     await application.shutdown()
   })
 
+  it('toggles plan mode with /plan, narrowing to read-only tools', 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 })
+    app.commands = createTerminalCommands({
+      session: () => session as never,
+      runtime: () => ({} as never),
+      ui: app.ui,
+      cwd: () => '/work/project',
+      sessionDirectory: () => '/isolated/account/history',
+      refresh: () => {},
+      changed: () => {},
+      planMode: () => app.planMode,
+      setPlanMode: enabled => app.setPlanMode(enabled),
+      shutdown: () => {},
+      setEditorText: () => {},
+      copyText: async () => {},
+      trajectory: {} as TerminalCommandHost['trajectory']
+    })
+    app.mountEditor()
+    app.submit('/plan')
+    await vi.waitFor(() => expect(setActiveToolsByName).toHaveBeenCalledWith(['read', 'grep']))
+    expect(setActiveToolsByName).toHaveBeenLastCalledWith(['read', 'grep'])
+    app.submit('/plan off')
+    await vi.waitFor(() => expect(setActiveToolsByName).toHaveBeenLastCalledWith(['read', 'bash', 'edit', 'write', 'grep', 'spawn_subagent']))
+    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') }) }