@xingular/harness 0.1.7 → 2.0.0

package/src/terminal/tui/runtime.ts

@@ -4,7 +4,7 @@ import {
   type AgentSession, type AgentSessionEventListener, type AgentSessionRuntime, type AgentSessionServices,
   type CreateAgentSessionRuntimeFactory, type ExtensionUIContext
 } from '@earendil-works/pi-coding-agent'
-import { closeSync, openSync, readSync, realpathSync } from 'node:fs'
+import { closeSync, existsSync, openSync, readSync, realpathSync } from 'node:fs'
 import { isAbsolute, join, relative, resolve, sep } from 'node:path'
 
 import terminalExtension from '../piExtension'
@@ -84,11 +84,19 @@ export interface TerminalSnapshot {
   readonly queue: Readonly<{ steering: readonly string[]; followUp: readonly string[] }>
 }
 
-export interface TerminalDecision extends TerminalQuestion { type: 'approval' | 'question'; target?: string; action?: string }
+export interface TerminalDecision extends TerminalQuestion { type: 'approval' | 'question'; target?: string; action?: string; rememberable?: boolean }
+
+export interface TerminalPermissionState {
+  readonly full: boolean
+  readonly globalTools: readonly string[]
+}
 
 export interface TerminalRuntime {
   pending(): Promise<TerminalDecision[]>
-  approve(requestId: string, decision: 'approved' | 'denied'): Promise<void>
+  approve(requestId: string, decision: 'approved' | 'denied', alwaysAllowTool?: boolean): Promise<void>
+  permissions(): Promise<TerminalPermissionState>
+  setFullPermission(enabled: boolean): Promise<void>
+  setGlobalTool(tool: string, allowed: boolean): Promise<void>
   answer(requestId: string, answer: QuestionAnswer): Promise<void>
   answerBatch(batchId: string, answers: Array<{ questionId: string; answer: QuestionAnswer }>): Promise<void>
   snapshot(): TerminalSnapshot
@@ -157,10 +165,11 @@ export async function createTerminalRuntime(args: string[], host: TerminalRuntim
   if (!agentDirValue || !isAbsolute(agentDirValue)) throw new Error('The Harness terminal requires its isolated account directory.')
   const agentDir = realpathSync(agentDirValue)
   const sessionDirectory = realpathSync(resolve(cwd, prepared.sessionDir))
-  if (prepared.session) {
-    const path = resolve(cwd, prepared.session)
-    assertTerminalHistoryPath(path, sessionDirectory)
-    assertTerminalSessionScope(path, cwd)
+  // Pi writes a session file only after its first message, so a restart before that has nothing to resume.
+  const resume = prepared.session && existsSync(resolve(cwd, prepared.session)) ? resolve(cwd, prepared.session) : null
+  if (resume) {
+    assertTerminalHistoryPath(resume, sessionDirectory)
+    assertTerminalSessionScope(resume, cwd)
   }
 
   // Claim before loading any plugin code and retain it in the trusted process across reloads.
@@ -233,7 +242,7 @@ export async function createTerminalRuntime(args: string[], host: TerminalRuntim
   }
   const native = await createAgentSessionRuntime(factory, {
     cwd, agentDir,
-    sessionManager: prepared.session ? SessionManager.open(resolve(cwd, prepared.session), sessionDirectory) : SessionManager.create(cwd, sessionDirectory),
+    sessionManager: resume ? SessionManager.open(resume, sessionDirectory) : SessionManager.create(cwd, sessionDirectory),
     sessionStartEvent: { type: 'session_start', reason: 'startup' }
   })
 
@@ -268,7 +277,13 @@ export async function createTerminalRuntime(args: string[], host: TerminalRuntim
       if (disposed) return []
       return (await controlCall<{ requests: TerminalDecision[] }>('terminal.pending')).requests
     },
-    approve: (requestId, decision) => decide('terminal.approve', { requestId, decision }),
+    approve: (requestId, decision, alwaysAllowTool = false) => decide('terminal.approve', { requestId, decision, alwaysAllow: alwaysAllowTool }),
+    async permissions() {
+      if (disposed) return { full: false, globalTools: [] }
+      return controlCall<TerminalPermissionState>('terminal.permissions.get')
+    },
+    setFullPermission: async enabled => { await decide('terminal.permissions.setFull', { enabled }) },
+    setGlobalTool: async (tool, allowed) => { await decide('terminal.permissions.setTool', { tool, allowed }) },
     answer: (requestId, answer) => decide('terminal.answer', { requestId, answer }),
     answerBatch: (batchId, answers) => decide('terminal.answers', { batchId, answers }),
     snapshot() {

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

@@ -0,0 +1,143 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { type Theme } from '@earendil-works/pi-coding-agent'
+import { Container, TuiAltScreen, TuiMainScreen, VStack, stripTerminalSequences, type Component, type Terminal } from '@earendil-works/pi-tui'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { createDock, createTerminalScreen, mountTerminalLayout, readScreenPreferences, scrollbackLines, writeScrollback, type ScreenHooks, type ScreenPreferences } from './screen'
+import { createHarnessTheme } from './theme'
+
+const directories: string[] = []
+afterEach(async () => { for (const directory of directories.splice(0)) await rm(directory, { recursive: true, force: true }) })
+
+const theme = createHarnessTheme({ getColorMode: () => 'truecolor' } as Theme)
+const hooks: ScreenHooks = { theme: () => theme, latestKey: () => 'ctrl+end', openUrl: vi.fn(), pasteClipboard: vi.fn() }
+const defaults = readScreenPreferences(undefined)
+const prefs = (mode: ScreenPreferences['mode']): ScreenPreferences => ({ ...defaults, mode })
+
+function fakeTerminal(columns = 40, rows = 12): Terminal {
+  return {
+    columns, rows, kittyProtocolActive: false, start: vi.fn(), stop: vi.fn(), drainInput: vi.fn(async () => {}), write: vi.fn(),
+    moveBy: vi.fn(), hideCursor: vi.fn(), showCursor: vi.fn(), clearLine: vi.fn(), clearFromCursor: vi.fn(), clearScreen: vi.fn(),
+    setTitle: vi.fn(), setProgress: vi.fn(), setProgramStatus: vi.fn()
+  } as unknown as Terminal
+}
+
+/** A transcript whose rows the test changes, and a three-row dock standing in for the rule, prompt and footer. */
+function panes(initial: string[]) {
+  let transcript = initial
+  const document = new Container()
+  document.addChild({ render: () => [...transcript], invalidate: () => {} })
+  const dock = new VStack([{ component: { render: () => ['─'.repeat(40), '❯ prompt', '? for shortcuts'], invalidate: () => {} }, shrink: 1, minSize: 0 }])
+  return { document, dock, set(lines: string[]) { transcript = lines } }
+}
+
+function rowOf(lines: string[]): Component {
+  return { render: () => [...lines], invalidate: () => {} }
+}
+
+function screenRows(tui: TuiAltScreen): string[] {
+  return tui.getScreenLines().map(line => stripTerminalSequences(line).trimEnd())
+}
+
+describe('terminal screen preferences', () => {
+  it('follows Pi fullscreen defaults when no account folder is prepared', () => {
+    expect(defaults).toEqual({ mode: 'fullscreen', exitOutput: 'transcript', scrollbar: 'auto', wheelScrollLines: 'auto', copyOnSelect: true })
+  })
+
+  it('reads the regular screen from the account settings', async () => {
+    const directory = await mkdtemp(join(tmpdir(), 'harness-screen-'))
+    directories.push(directory)
+    await writeFile(join(directory, 'settings.json'), JSON.stringify({ tuiMode: 'regular' }))
+    expect(readScreenPreferences(directory).mode).toBe('regular')
+  })
+})
+
+describe('terminal screen layout', () => {
+  it('keeps the dock on the last rows while the transcript is short', () => {
+    const tui = createTerminalScreen(fakeTerminal(40, 12), prefs('fullscreen'), hooks) as TuiAltScreen
+    const { document, dock } = panes(['Welcome'])
+    mountTerminalLayout(tui, { document, dock }, prefs('fullscreen'), hooks)
+    tui.start()
+    tui.renderNow(true)
+    const rows = screenRows(tui)
+    expect(rows).toHaveLength(12)
+    expect(rows[0]).toBe('Welcome')
+    expect(rows.slice(-3)).toEqual(['─'.repeat(40), '❯ prompt', '? for shortcuts'])
+    tui.stop()
+  })
+
+  it('does not move the dock as the transcript grows', () => {
+    const tui = createTerminalScreen(fakeTerminal(40, 12), prefs('fullscreen'), hooks) as TuiAltScreen
+    const { document, dock, set } = panes(['Welcome'])
+    mountTerminalLayout(tui, { document, dock }, prefs('fullscreen'), hooks)
+    tui.start()
+    tui.renderNow(true)
+    set(Array.from({ length: 30 }, (_, index) => `message ${index}`))
+    tui.renderNow(true)
+    const rows = screenRows(tui)
+    expect(rows).toHaveLength(12)
+    expect(rows.slice(-3)).toEqual(['─'.repeat(40), '❯ prompt', '? for shortcuts'])
+    expect(rows[8]).toBe('message 29')
+    tui.stop()
+  })
+
+  it('scrolls the transcript above a dock that stays where it is', () => {
+    const tui = createTerminalScreen(fakeTerminal(40, 12), prefs('fullscreen'), hooks) as TuiAltScreen
+    const { document, dock, set } = panes(Array.from({ length: 30 }, (_, index) => `message ${index}`))
+    mountTerminalLayout(tui, { document, dock }, prefs('fullscreen'), hooks)
+    tui.start()
+    tui.renderNow(true)
+    expect(tui.isFollowingOutput).toBe(true)
+    tui.scrollBy(-10)
+    tui.renderNow(true)
+    expect(tui.isFollowingOutput).toBe(false)
+    const rows = screenRows(tui)
+    expect(rows.slice(-3)).toEqual(['─'.repeat(40), '❯ prompt', '? for shortcuts'])
+    expect(rows.some(row => row === 'message 29')).toBe(false)
+    set(['message 0'])
+    tui.stop()
+  })
+
+  it('shows the first rows of a long queue while the prompt and status stay whole', () => {
+    const tui = createTerminalScreen(fakeTerminal(40, 12), prefs('fullscreen'), hooks) as TuiAltScreen
+    const queued = Array.from({ length: 20 }, (_, index) => `queued ${index}`)
+    const dock = createDock({
+      title: rowOf(['title']), above: rowOf([]), queue: rowOf(queued), below: rowOf([]), footer: rowOf(['status']),
+      editor: rowOf(['─'.repeat(40), '❯ prompt', '─'.repeat(40), '? for shortcuts'])
+    })
+    const document = new Container()
+    document.addChild(rowOf(['Welcome']))
+    mountTerminalLayout(tui, { document, dock }, prefs('fullscreen'), hooks)
+    tui.start()
+    tui.renderNow(true)
+    const rows = screenRows(tui)
+    expect(rows).toHaveLength(12)
+    expect(rows.slice(-5)).toEqual(['─'.repeat(40), '❯ prompt', '─'.repeat(40), '? for shortcuts', 'status'])
+    expect(rows).toContain('queued 0')
+    expect(rows).not.toContain('queued 19')
+    tui.stop()
+  })
+
+  it('flows the regular screen in order without a viewport', () => {
+    const tui = createTerminalScreen(fakeTerminal(), prefs('regular'), hooks)
+    expect(tui).toBeInstanceOf(TuiMainScreen)
+    const { document, dock } = panes(['Welcome'])
+    expect(mountTerminalLayout(tui, { document, dock }, prefs('regular'), hooks)).toBeUndefined()
+    expect(tui.children).toEqual([document, dock])
+  })
+})
+
+describe('terminal scrollback on exit', () => {
+  it('truncates the conversation to the terminal width', () => {
+    const component: Component = { render: () => ['x'.repeat(30)], invalidate: () => {} }
+    expect(scrollbackLines(component, 10).map(line => stripTerminalSequences(line))).toEqual(['x'.repeat(10)])
+  })
+
+  it('writes each line with its styles reset and CRLF endings', () => {
+    const terminal = fakeTerminal()
+    writeScrollback(terminal, ['first', 'second'])
+    expect(terminal.write).toHaveBeenCalledWith('first\x1b[0m\r\nsecond\x1b[0m\r\n')
+  })
+})

package/src/terminal/tui/screen.ts

@@ -0,0 +1,121 @@
+// Screen mode and layout. Pi's fullscreen settings still choose the mode; Harness supplies its own composition.
+import { SettingsManager, copyToClipboard, type FullscreenExitOutput, type Theme, type TuiMode } from '@earendil-works/pi-coding-agent'
+import { ScrollView, TuiAltScreen, TuiMainScreen, VStack, isViewportTUI, truncateToWidth, type Component, type Terminal, type TuiAltScreenOptions } from '@earendil-works/pi-tui'
+
+export interface DockSlots {
+  readonly title: Component
+  readonly above: Component
+  readonly queue: Component
+  readonly editor: Component
+  readonly below: Component
+  readonly footer: Component
+}
+
+export type TerminalScreen = TuiMainScreen | TuiAltScreen
+
+export interface ScreenPreferences {
+  readonly mode: TuiMode
+  readonly exitOutput: FullscreenExitOutput
+  readonly scrollbar: ReturnType<SettingsManager['getFullscreenScrollbar']>
+  readonly wheelScrollLines: ReturnType<SettingsManager['getFullscreenWheelScrollLines']>
+  readonly copyOnSelect: boolean
+}
+
+export interface ScreenHooks {
+  theme(): Theme
+  latestKey(): string | undefined
+  openUrl(url: string): void
+  pasteClipboard(): void
+}
+
+export interface TerminalPanes {
+  readonly document: Component
+  readonly dock: Component
+}
+
+export function readScreenPreferences(agentDir: string | undefined): ScreenPreferences {
+  // Without an account folder there is no settings file to read, so Pi's defaults apply.
+  const settings = agentDir ? SettingsManager.create(process.cwd(), agentDir) : SettingsManager.inMemory()
+  return {
+    mode: settings.getTuiMode(),
+    exitOutput: settings.getFullscreenExitOutput(),
+    scrollbar: settings.getFullscreenScrollbar(),
+    wheelScrollLines: settings.getFullscreenWheelScrollLines(),
+    copyOnSelect: settings.getFullscreenCopyOnSelect()
+  }
+}
+
+export function createTerminalScreen(terminal: Terminal, preferences: ScreenPreferences, hooks: ScreenHooks): TerminalScreen {
+  if (preferences.mode === 'regular') return new TuiMainScreen(terminal)
+  const { theme } = hooks
+  const options: TuiAltScreenOptions = {
+    wheelScrollLines: preferences.wheelScrollLines,
+    copyOnSelect: preferences.copyOnSelect,
+    searchMatchStyle: text => theme().underline(theme().bg('searchMatchBg', theme().fg('searchMatchText', text))),
+    searchCurrentMatchStyle: text => theme().bold(theme().inverse(theme().bg('searchMatchBg', theme().fg('searchMatchText', text)))),
+    searchNavigationButtonStyle: (text, hovered) => hovered ? theme().underline(text) : text,
+    scrollToEndIndicator: () => {
+      const key = hooks.latestKey()
+      return theme().bg('selectedBg', theme().fg('text', ` ↓ Jump to latest message${key ? ` · ${keyLabel(key)}` : ''} `))
+    },
+    openUrl: hooks.openUrl,
+    onRightClickPaste: hooks.pasteClipboard,
+    copySelection: copySelectionText
+  }
+  return new TuiAltScreen(terminal, undefined, undefined, options)
+}
+
+/** The prompt and status keep their full height; when the screen is short, queued messages and widgets show their first rows and scroll for the rest. */
+export function createDock(slots: DockSlots): VStack {
+  const region = (component: Component) => new ScrollView(component)
+  return new VStack([
+    { component: slots.title, shrink: 0 },
+    { component: region(slots.above), shrink: 1, minSize: 0 },
+    { component: region(slots.queue), shrink: 1, minSize: 0 },
+    { component: slots.editor, shrink: 0 },
+    { component: region(slots.below), shrink: 1, minSize: 0 },
+    { component: slots.footer, shrink: 0 }
+  ])
+}
+
+/** Fullscreen keeps the dock on the last rows and scrolls only the transcript above it; regular mode flows in order. */
+export function mountTerminalLayout(tui: TerminalScreen, panes: TerminalPanes, preferences: ScreenPreferences, hooks: ScreenHooks): ScrollView | undefined {
+  if (!isViewportTUI(tui)) {
+    tui.addChild(panes.document)
+    tui.addChild(panes.dock)
+    return undefined
+  }
+  const transcript = new ScrollView(panes.document, {
+    follow: 'end', primary: true, overscroll: 'chain', scrollbar: preferences.scrollbar,
+    scrollbarTrackStyle: text => hooks.theme().fg('scrollbarTrack', text),
+    scrollbarThumbStyle: text => hooks.theme().fg('scrollbarThumb', text)
+  })
+  tui.setLayoutRoot(new VStack([
+    { component: transcript, basis: 0, grow: 1, shrink: 1, minSize: 1 },
+    { component: panes.dock, basis: 'auto', grow: 0, shrink: 1, minSize: 1 }
+  ]))
+  return transcript
+}
+
+/** Rendered before the alternate screen is left, because the components are disposed afterwards. */
+export function scrollbackLines(component: Component, width: number): string[] {
+  return component.render(width).map(line => truncateToWidth(line, width, ''))
+}
+
+/** Leaving fullscreen discards the alternate screen, so the conversation is copied into normal scrollback. */
+export function writeScrollback(terminal: Terminal, lines: string[]): void {
+  terminal.write(lines.map(line => `${line}\x1b[0m`).join('\r\n') + '\r\n')
+}
+
+function keyLabel(key: string): string {
+  return key.replace(/(^|\+)([a-z])/g, (_match, separator: string, letter: string) => separator + letter.toUpperCase())
+}
+
+async function copySelectionText(text: string): Promise<boolean | string> {
+  try {
+    await copyToClipboard(text)
+    return true
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error)
+  }
+}

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

@@ -0,0 +1,71 @@
+import type { AutocompleteProvider } from '@earendil-works/pi-tui'
+import { describe, expect, it } from 'vitest'
+
+import { expandSkillInvocation, skillCompletions, type SkillEntry } from './skillInvocation'
+
+const skills: SkillEntry[] = [
+  { name: 'review', description: 'Review a change' },
+  { name: 'refactor', description: 'Refactor a module' },
+  { name: 'deploy', description: 'Ship a build' }
+]
+const names = new Set(skills.map((skill) => skill.name))
+const signal = new AbortController().signal
+
+const base: AutocompleteProvider = {
+  getSuggestions: async () => ({ items: [{ value: 'accounts', label: 'accounts' }], prefix: '/a' }),
+  applyCompletion: (lines) => ({ lines, cursorLine: 0, cursorCol: 0 })
+}
+
+describe('invoking a skill with $name', () => {
+  it('rewrites a leading $name of a loaded skill into the form Pi expands', () => {
+    expect(expandSkillInvocation('$review the module', names)).toBe('/skill:review the module')
+    expect(expandSkillInvocation('  $deploy', names)).toBe('/skill:deploy')
+  })
+
+  it('leaves text alone when the name is not a loaded skill, or the $ is not a skill', () => {
+    expect(expandSkillInvocation('$unknown the module', names)).toBe('$unknown the module')
+    expect(expandSkillInvocation('It costs $5 today', names)).toBe('It costs $5 today')
+    expect(expandSkillInvocation('$5 budget', names)).toBe('$5 budget')
+    expect(expandSkillInvocation('/review module', names)).toBe('/review module')
+  })
+})
+
+describe('the $ completions', () => {
+  it('offers the skills that start with what has been typed after a word-start $', async () => {
+    const provider = skillCompletions(base, () => skills)
+    const suggestions = await provider.getSuggestions(['look at $rev'], 0, 12, { signal })
+    expect(suggestions).toEqual({
+      items: [{ value: 'review', label: '$review', description: 'Review a change' }],
+      prefix: '$rev'
+    })
+  })
+
+  it('offers every skill at a bare $, and nothing when no skill matches', async () => {
+    const provider = skillCompletions(base, () => skills)
+    expect((await provider.getSuggestions(['$'], 0, 1, { signal }))?.items.map((item) => item.value)).toEqual(['review', 'refactor', 'deploy'])
+    expect(await provider.getSuggestions(['cost $5'], 0, 7, { signal })).toBeNull()
+  })
+
+  it('gives a line that starts with a skill invocation no file completions in its arguments', async () => {
+    const files: AutocompleteProvider = { getSuggestions: async () => ({ items: [{ value: 'src/', label: 'src/' }], prefix: 'sr' }), applyCompletion: (lines) => ({ lines, cursorLine: 0, cursorCol: 0 }) }
+    const provider = skillCompletions(files, () => skills)
+    expect(await provider.getSuggestions(['$review '], 0, 8, { signal })).toBeNull()
+    expect(await provider.getSuggestions(['$review check the sr'], 0, 18, { signal })).toBeNull()
+    expect((await provider.getSuggestions(['check the sr'], 0, 12, { signal }))?.items).toEqual([{ value: 'src/', label: 'src/' }])
+  })
+
+  it('hands every other completion to the base provider', async () => {
+    const provider = skillCompletions(base, () => skills)
+    expect(await provider.getSuggestions(['/a'], 0, 2, { signal })).toEqual({ items: [{ value: 'accounts', label: 'accounts' }], prefix: '/a' })
+  })
+
+  it('inserts the chosen skill as $name and a space in place of the typed prefix', () => {
+    const provider = skillCompletions(base, () => skills)
+    const completed = provider.applyCompletion(['look at $re and more'], 0, 11, { value: 'review', label: '$review' }, '$re')
+    expect(completed).toEqual({ lines: ['look at $review  and more'], cursorLine: 0, cursorCol: 16 })
+  })
+
+  it('opens the menu when a $ is typed', () => {
+    expect(skillCompletions(base, () => skills).triggerCharacters).toContain('$')
+  })
+})

package/src/terminal/tui/skillInvocation.ts

@@ -0,0 +1,51 @@
+// A skill is invoked as `$name` in the terminal. Pi expands only `/skill:name`, so the terminal
+// rewrites the leading `$name` before the prompt is sent, and offers the loaded skills at a `$`.
+import type { AutocompleteItem, AutocompleteProvider, AutocompleteSuggestions } from '@earendil-works/pi-tui'
+
+export interface SkillEntry {
+  name: string
+  description: string
+}
+
+/** Rewrites a leading `$name` of a loaded skill into `/skill:name`. Anything else passes through, so `$5` stays text. */
+export function expandSkillInvocation(text: string, skills: ReadonlySet<string>): string {
+  const trimmed = text.trimStart()
+  const match = /^\$(\S+)(?=\s|$)/.exec(trimmed)
+  if (!match || !skills.has(match[1]!)) return text
+  return `/skill:${match[1]}${trimmed.slice(match[0].length)}`
+}
+
+/** A `$` that starts a word, and the partial name after it, at the cursor. */
+const SKILL_TOKEN = /(?:^|\s)\$([^\s$]*)$/
+/** A line whose first word is a skill invocation. */
+const SKILL_LINE = /^\s*\$\S/
+
+/** Offers the loaded skills at a `$` that starts a word. Every other completion is `base`'s. */
+export function skillCompletions(base: AutocompleteProvider, skills: () => readonly SkillEntry[]): AutocompleteProvider {
+  return {
+    triggerCharacters: [...(base.triggerCharacters ?? []), '$'],
+    async getSuggestions(lines, cursorLine, cursorCol, options): Promise<AutocompleteSuggestions | null> {
+      const line = lines[cursorLine] ?? ''
+      const token = SKILL_TOKEN.exec(line.slice(0, cursorCol))
+      if (token) {
+        const partial = token[1]!
+        const items: AutocompleteItem[] = skills()
+          .filter((skill) => skill.name.startsWith(partial))
+          .map((skill) => ({ value: skill.name, label: `$${skill.name}`, description: skill.description }))
+        return items.length ? { items, prefix: `$${partial}` } : null
+      }
+      // The arguments of a line that starts with a skill invocation are free text, not file paths.
+      if (SKILL_LINE.test(line)) return null
+      return base.getSuggestions(lines, cursorLine, cursorCol, options)
+    },
+    applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+      if (!prefix.startsWith('$')) return base.applyCompletion(lines, cursorLine, cursorCol, item, prefix)
+      const line = lines[cursorLine] ?? ''
+      const start = cursorCol - prefix.length
+      const inserted = `$${item.value} `
+      const newLines = [...lines]
+      newLines[cursorLine] = `${line.slice(0, start)}${inserted}${line.slice(cursorCol)}`
+      return { lines: newLines, cursorLine, cursorCol: start + inserted.length }
+    }
+  }
+}

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

@@ -2,69 +2,47 @@ import { initTheme, Theme } from '@earendil-works/pi-coding-agent'
 import { stripTerminalSequences, visibleWidth } from '@earendil-works/pi-tui'
 import { describe, expect, it } from 'vitest'
 
-import { contextGauge, displayPath, renderStatusBand, type BandState } from './status'
+import { displayProjectName, renderStatusBand, type BandState } from './status'
 import { createHarnessTheme } from './theme'
 
 initTheme('dark', false)
 const theme = createHarnessTheme({ getColorMode: () => 'truecolor' } as Theme)
 const state: BandState = {
   cwd: '/work/project', model: { name: 'Claude Sonnet 4.6', reasoning: true, contextWindow: 200_000 },
-  thinkingLevel: 'high', branch: 'main', contextPercent: 25, contextWindow: 200_000,
-  costUsd: 0.15, subscription: false, running: false, elapsedMs: 0
+  thinkingLevel: 'high', branch: 'main', account: 'Tanny', inputTokens: 1300, outputTokens: 50,
+  tokensPerSecond: 30
 }
 
-describe('Oh My Pi status band', () => {
-  it('renders the actual model, effort, branch, cost, and embedded context gauge', () => {
+describe('composer status band', () => {
+  it('renders the four text groups in order with distinct colors', () => {
     const line = renderStatusBand(state, 120, theme)
-    const plain = stripTerminalSequences(line)
-    expect(plain).toContain('π > ◒ Sonnet 4.6 > 📁 /work/project > ⑂ main > $0.15 ▶')
-    expect(plain).toContain('25%')
-    expect(plain).toMatch(/200K─$/)
-    expect(visibleWidth(line)).toBe(120)
-    expect(line).toContain('48;2;15;18;22')
-    expect(line).toContain('38;2;0;180;255')
+    expect(stripTerminalSequences(line)).toBe('project | main | Tanny · Sonnet 4.6 · high | 30 tok/s in 1,300 out 50')
+    for (const color of ['38;2;232;236;244', '38;2;0;255;136', '38;2;0;180;255', '38;2;212;192;144']) {
+      expect(line).toContain(color)
+    }
+    expect(visibleWidth(line)).toBe(stripTerminalSequences(line).length)
+  })
+
+  it('uses the last path component and a readable root fallback', () => {
+    expect(displayProjectName('/work/a/long-project/')).toBe('long-project')
+    expect(displayProjectName('/')).toBe('/')
   })
 
-  it('stays within every narrow and wide terminal with wide, colored, and untrusted metadata', () => {
+  it('shows text fallbacks when branch, account, model, and rate are unavailable', () => {
+    const line = renderStatusBand({ ...state, branch: null, account: undefined, model: undefined, tokensPerSecond: null }, 120, theme)
+    expect(stripTerminalSequences(line)).toBe('project | — | account unknown · no-model · high | — tok/s in 1,300 out 50')
+  })
+
+  it('stays within narrow terminal widths and sanitizes metadata', () => {
     for (let width = 1; width <= 180; width++) {
       const line = renderStatusBand({ ...state,
-        cwd: '/work/日本語/long-project-name/with-many-parts',
+        cwd: '/work/日本語/long-project-name',
         branch: '\x1b]2;malicious title\x07main\nother',
         model: { ...state.model!, name: '非常に長い名前'.repeat(20) }
       }, width, theme)
       expect(visibleWidth(line), `width ${width}`).toBeLessThanOrEqual(width)
-      expect(line).not.toContain('malicious title')
-      expect(line).not.toContain('\n')
-    }
-  })
-
-  it('never invents model, quota, usage, or git data while startup context is unknown', () => {
-    const plain = stripTerminalSequences(renderStatusBand({ ...state,
-      model: undefined, branch: null, contextWindow: 0, contextPercent: null, costUsd: 0
-    }, 80, theme))
-    expect(plain).toContain('⬢ no-model')
-    expect(plain).not.toMatch(/0%|200K|main|\$|quota|plan|collab/i)
-  })
-
-  it('clamps gauge values and omits an unknown percentage while retaining the window', () => {
-    for (const percent of [null, -20, 0, 50, 100, 120, NaN]) {
-      for (const width of [0, 1, 5, 16, 60]) {
-        const gauge = contextGauge(width, percent, 200_000, theme)
-        expect(visibleWidth(gauge)).toBe(width)
-        expect(stripTerminalSequences(gauge)).not.toContain('NaN')
-      }
+      expect(stripTerminalSequences(line)).not.toContain('malicious title')
+      expect(stripTerminalSequences(line)).not.toContain('\n')
     }
-    expect(stripTerminalSequences(contextGauge(20, null, 200_000, theme))).not.toContain('%')
-  })
-
-  it('keeps sibling directories outside home and shows existing subscription and overflow states', () => {
-    expect(displayPath('/home/test/project', '/home/test')).toBe('~/project')
-    expect(displayPath('/home/test-other/project', '/home/test')).toBe('/home/test-other/project')
-    const line = stripTerminalSequences(renderStatusBand({ ...state,
-      subscription: true, costUsd: 0, running: true, elapsedMs: 65_000, hiddenAbove: 4
-    }, 160, theme))
-    expect(line).toContain('1m 5s')
-    expect(line).toContain('$0.00 (sub)')
-    expect(line).toContain('↑ 4 more')
   })
 })