@xingular/harness 0.1.5 → 0.1.7

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

@@ -0,0 +1,218 @@
+import type { AgentSession, ExtensionUIContext } from '@earendil-works/pi-coding-agent'
+import { describe, expect, it, vi } from 'vitest'
+import { createTerminalCommands, type TerminalCommandHost } from './commands'
+
+function setup() {
+  const ui = {
+    notify: vi.fn(), select: vi.fn(), confirm: vi.fn(), input: vi.fn(),
+    theme: { name: 'harness-titanium' }
+  } as unknown as ExtensionUIContext
+  const session = {
+    extensionRunner: { getRegisteredCommands: () => [{ name: 'accounts', description: 'Manage accounts' }] },
+    resourceLoader: {
+      getPrompts: () => ({ prompts: [{ name: 'review', description: 'Review code' }] }),
+      getSkills: () => ({ skills: [{ name: 'diagnose', description: 'Diagnose a problem' }] })
+    },
+    settingsManager: { getEnableSkillCommands: () => true },
+    compact: vi.fn(), reload: vi.fn(), setSessionName: vi.fn(),
+    getLastAssistantText: vi.fn(() => 'Actual assistant response'),
+    getSessionStats: () => ({ sessionId: 'real-session', tokens: { input: 7 } }),
+    exportToHtml: vi.fn(async (path: string) => path), exportToJsonl: vi.fn((path: string) => path)
+  } as unknown as AgentSession
+  const runtime = { newSession: vi.fn(), switchSession: vi.fn(), fork: vi.fn(), importFromJsonl: vi.fn(), reload: vi.fn(), navigateTree: vi.fn(), installationDeviceId: vi.fn(async () => '12345678-1234-4234-8234-123456789abc') }
+  const host: TerminalCommandHost = {
+    session: () => session, runtime: () => runtime as unknown as ReturnType<TerminalCommandHost['runtime']>, ui,
+    cwd: () => '/isolated/project', sessionDirectory: () => '/isolated/account/history',
+    refresh: vi.fn(), shutdown: vi.fn(), setEditorText: vi.fn(), copyText: vi.fn(async () => {}),
+    hotkeys: () => 'Escape: interrupt', changelog: async () => 'Harness release notes'
+  }
+  return { host, session, runtime, ui, commands: createTerminalCommands(host) }
+}
+
+describe('owned terminal commands', () => {
+  it('leaves ordinary prompts and supported extension/resource commands for the SDK', async () => {
+    const { commands, ui } = setup()
+    for (const text of ['hello', '/accounts', '/review module', '/skill:diagnose trace']) {
+      expect(await commands.execute(text)).toBe(false)
+    }
+    expect(ui.notify).not.toHaveBeenCalled()
+  })
+
+  it('consumes unknown slash commands without sending them to the model', async () => {
+    const { commands, ui } = setup()
+    expect(await commands.execute('/typo dangerous operation')).toBe(true)
+    expect(ui.notify).toHaveBeenCalledWith(expect.stringContaining('Unknown command: /typo'), 'error')
+  })
+
+  it('populates completion from builtins and loaded resources', () => {
+    const { commands } = setup()
+    const names = commands.completions().map(item => item.name)
+    expect(names).toEqual(expect.arrayContaining(['model', 'resume', 'accounts', 'review', 'skill:diagnose']))
+    expect(new Set(names).size).toBe(names.length)
+  })
+
+  it('respects disabled skill commands', () => {
+    const { commands, session } = setup()
+    vi.spyOn(session.settingsManager, 'getEnableSkillCommands').mockReturnValue(false)
+    expect(commands.completions().map(item => item.name)).not.toContain('skill:diagnose')
+  })
+
+  it('uses the scope checked runtime for explicit resume and import paths', async () => {
+    const { commands, runtime } = setup()
+    await commands.execute('/resume /isolated/account/history/session.jsonl')
+    expect(runtime.switchSession).toHaveBeenCalledWith('/isolated/account/history/session.jsonl')
+    await commands.execute('/import other.jsonl')
+    expect(runtime.importFromJsonl).toHaveBeenCalledWith('/isolated/project/other.jsonl')
+    await commands.execute('/new')
+    expect(runtime.newSession).toHaveBeenCalledOnce()
+  })
+
+  it('passes the Harness installation device ID to direct OAuth sign-in', async () => {
+    const { commands, session, runtime } = setup()
+    const login = vi.fn(async (_provider: string, _type: string, _interaction: unknown, options?: { getDeviceId?: () => string }) => options)
+    Object.assign(session, { modelRuntime: {
+      getProviders: () => [{ id: 'openai', name: 'OpenAI', auth: { oauth: {}, apiKey: undefined } }],
+      login
+    } })
+
+    await commands.execute('/login openai')
+
+    expect(runtime.installationDeviceId).toHaveBeenCalledOnce()
+    expect(login.mock.calls[0]?.[3]?.getDeviceId?.()).toBe('12345678-1234-4234-8234-123456789abc')
+  })
+
+  it('reports rejected navigation without claiming success', async () => {
+    const { commands, runtime, ui } = setup()
+    runtime.switchSession.mockRejectedValue(new Error('Session is outside the prepared project scope'))
+    expect(await commands.execute('/resume /isolated/account/history/session.jsonl')).toBe(true)
+    expect(ui.notify).toHaveBeenCalledWith('Session is outside the prepared project scope', 'error')
+  })
+
+  it('copies actual assistant text and handles missing responses', async () => {
+    const { commands, host, session, ui } = setup()
+    await commands.execute('/copy')
+    expect(host.copyText).toHaveBeenCalledWith('Actual assistant response')
+    vi.mocked(session.getLastAssistantText).mockReturnValue(undefined)
+    await commands.execute('/copy')
+    expect(ui.notify).toHaveBeenCalledWith('No assistant response to copy yet', 'error')
+  })
+
+  it('keeps multiline compaction instructions and session names', async () => {
+    const { commands, session } = setup()
+    await commands.execute('/compact Keep the API\nand authentication details')
+    expect(session.compact).toHaveBeenCalledWith('Keep the API\nand authentication details')
+    await commands.execute('/name Unicode 知識 🧠')
+    expect(session.setSessionName).toHaveBeenCalledWith('Unicode 知識 🧠')
+  })
+
+  it('exports supported formats through native session APIs', async () => {
+    const { commands, session } = setup()
+    await commands.execute('/export notes.jsonl')
+    expect(session.exportToJsonl).toHaveBeenCalledWith('/isolated/project/notes.jsonl')
+    await commands.execute('/export notes.html')
+    expect(session.exportToHtml).toHaveBeenCalledWith('/isolated/project/notes.html', { themeName: 'harness-titanium' })
+  })
+
+  it('does not upload anything after a declined share confirmation', async () => {
+    const { commands, ui, session } = setup()
+    vi.mocked(ui.confirm).mockResolvedValue(false)
+    await commands.execute('/share')
+    expect(ui.confirm).toHaveBeenCalledOnce()
+    expect(session.exportToHtml).not.toHaveBeenCalled()
+  })
+
+  it('shows actual application keyboard bindings and release notes', async () => {
+    const { commands, ui } = setup()
+    await commands.execute('/hotkeys')
+    expect(ui.notify).toHaveBeenCalledWith('Escape: interrupt', 'info')
+    await commands.execute('/changelog')
+    expect(ui.notify).toHaveBeenCalledWith('Harness release notes', 'info')
+  })
+
+  it('exits through the application lifecycle', async () => {
+    const { commands, host } = setup()
+    await commands.execute('/quit')
+    expect(host.shutdown).toHaveBeenCalledOnce()
+  })
+  it('validates thinking levels before mutating the session', async () => {
+    const { commands, session, ui } = setup()
+    Object.assign(session, { getAvailableThinkingLevels: () => ['off', 'high'], setThinkingLevel: vi.fn() })
+    await commands.execute('/thinking high')
+    expect(session.setThinkingLevel).toHaveBeenCalledWith('high', { persist: true })
+    await commands.execute('/thinking fabricated')
+    expect(session.setThinkingLevel).toHaveBeenCalledTimes(1)
+    expect(ui.notify).toHaveBeenCalledWith('Available thinking levels: off, high', 'error')
+  })
+
+  it('clones the real leaf through the runtime without inventing history', async () => {
+    const { commands, session, runtime, host } = setup()
+    Object.assign(session, { sessionManager: { getLeafId: () => 'leaf-id' } })
+    runtime.fork.mockResolvedValue({ cancelled: false })
+    await commands.execute('/clone')
+    expect(runtime.fork).toHaveBeenCalledWith('leaf-id', { position: 'at' })
+    expect(host.setEditorText).toHaveBeenCalledWith('')
+  })
+
+  it('uses masked input for secret provider credentials', async () => {
+    const { commands, session, host, ui } = setup()
+    const login = vi.fn(async (_provider, _type, interaction) => {
+      expect(await interaction.prompt({ type: 'secret', message: 'API key' })).toBe('private-key')
+    })
+    Object.assign(session, { modelRuntime: {
+      getProviders: () => [{ id: 'provider', name: 'Provider', auth: { apiKey: { login: true } } }], login
+    } })
+    host.secretInput = vi.fn(async () => 'private-key')
+    await commands.execute('/login provider')
+    expect(host.secretInput).toHaveBeenCalledWith('API key', undefined, { signal: undefined })
+    expect(ui.input).not.toHaveBeenCalled()
+    expect(ui.notify).not.toHaveBeenCalledWith(expect.stringContaining('private-key'), expect.anything())
+  })
+
+  it('fails closed when secure credential input is unavailable', async () => {
+    const { commands, session, ui } = setup()
+    Object.assign(session, { modelRuntime: {
+      getProviders: () => [{ id: 'provider', name: 'Provider', auth: { apiKey: { login: true } } }],
+      login: async (_provider: string, _type: string, interaction: { prompt(prompt: unknown): Promise<string> }) => interaction.prompt({ type: 'secret', message: 'API key' })
+    } })
+    await commands.execute('/login provider')
+    expect(ui.input).not.toHaveBeenCalled()
+    expect(ui.notify).toHaveBeenCalledWith('Secure credential entry is unavailable', 'error')
+  })
+
+  it('rejects resume paths outside account history before runtime navigation', async () => {
+    const { commands, runtime, ui } = setup()
+    await commands.execute('/resume /other-account/session.jsonl')
+    expect(runtime.switchSession).not.toHaveBeenCalled()
+    expect(ui.notify).toHaveBeenCalledWith(expect.stringContaining('this account history folder'), 'error')
+  })
+
+  it('routes trust through the existing protected plugin workflow', async () => {
+    const { commands, session } = setup()
+    Object.assign(session, { prompt: vi.fn(async () => {}) })
+    vi.spyOn(session.extensionRunner, 'getRegisteredCommands').mockReturnValue([{ name: 'plugins' }] as never)
+    await commands.execute('/trust')
+    expect(session.prompt).toHaveBeenCalledWith('/plugins')
+  })
+
+  it('opens a reviewable Harness issue draft without attaching session history', async () => {
+    const { commands, host, ui } = setup()
+    host.openExternal = vi.fn(async () => {})
+    vi.mocked(ui.confirm).mockResolvedValue(false)
+    await commands.execute('/bug Unicode issue 知識')
+    expect(host.openExternal).not.toHaveBeenCalled()
+    vi.mocked(ui.confirm).mockResolvedValue(true)
+    await commands.execute('/bug Unicode issue 知識')
+    const url = new URL(vi.mocked(host.openExternal).mock.calls[0][0])
+    expect(url.pathname).toBe('/tanntnny/xingular-harness/issues/new')
+    expect(url.searchParams.get('title')).toBe('Unicode issue 知識')
+    expect(url.searchParams.get('body')).toContain('Harness')
+  })
+
+  it('reloads through the stable runtime lifecycle', async () => {
+    const { commands, runtime, session } = setup()
+    await commands.execute('/reload')
+    expect(runtime.reload).toHaveBeenCalledOnce()
+    expect(session.reload).not.toHaveBeenCalled()
+  })
+
+})

package/src/terminal/tui/commands.ts

@@ -0,0 +1,361 @@
+import { execFile } from 'node:child_process'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { isAbsolute, join, relative, resolve } from 'node:path'
+import { promisify } from 'node:util'
+import { ModelSelectorComponent, TreeSelectorComponent, SessionManager, type AgentSession, type ExtensionUIContext } from '@earendil-works/pi-coding-agent'
+import { SettingsPanel, type TerminalSettingItem } from './settings'
+import manifest from '../../../package.json'
+import type { TerminalRuntime } from './runtime'
+
+export interface TerminalCommandHost {
+  session(): AgentSession
+  /** Navigation is scope checked by the Harness runtime adapter. */
+  runtime(): Pick<TerminalRuntime, 'newSession' | 'switchSession' | 'fork' | 'importFromJsonl' | 'reload' | 'navigateTree' | 'installationDeviceId'>
+  ui: ExtensionUIContext
+  cwd(): string
+  sessionDirectory(): string
+  refresh(): void
+  shutdown(): void
+  setEditorText(text: string): void
+  copyText(text: string): Promise<void>
+  secretInput?(title: string, placeholder?: string, options?: { signal?: AbortSignal }): Promise<string | undefined>
+  openExternal?(url: string): Promise<void>
+  suspend?(): Promise<void>
+  hotkeys?(): string
+  changelog?(): Promise<string>
+}
+
+export interface TerminalCommandCompletion { name: string; description?: string }
+
+const BUILTINS: TerminalCommandCompletion[] = [
+  { name: 'help', description: 'Available terminal commands' },
+  { name: 'new', description: 'Start a new session' },
+  { name: 'resume', description: 'Resume a session in this account and folder' },
+  { name: 'tree', description: 'Navigate the session tree' },
+  { name: 'fork', description: 'Fork from a user message' },
+  { name: 'model', description: 'Choose a model' },
+  { name: 'thinking', description: 'Choose thinking effort' },
+  { name: 'clone', description: 'Clone the current branch to a new session' },
+  { name: 'scoped-models', description: 'Choose models for cycling' },
+  { name: 'settings', description: 'Session and terminal settings' },
+  { name: 'name', description: 'Name the current session' },
+  { name: 'session', description: 'Current session statistics' },
+  { name: 'compact', description: 'Compact the current context' },
+  { name: 'reload', description: 'Reload trusted resources and keyboard bindings' },
+  { name: 'trust', description: 'Review plugin code and project trust' },
+  { name: 'bug', description: 'Open a Harness issue draft' },
+  { name: 'login', description: 'Sign in to a provider in this isolated account' },
+  { name: 'logout', description: 'Remove a stored provider credential' },
+  { name: 'export', description: 'Export this branch to HTML or JSONL' },
+  { name: 'import', description: 'Import a session JSONL file' },
+  { name: 'share', description: 'Share an HTML export as a secret GitHub gist' },
+  { name: 'copy', description: 'Copy the last assistant response' },
+  { name: 'changelog', description: 'Harness release notes' },
+  { name: 'hotkeys', description: 'Keyboard controls' },
+  { name: 'quit', description: 'Restore the terminal and exit' }
+]
+
+export function createTerminalCommands(host: TerminalCommandHost) {
+  const notify = (text: string) => host.ui.notify(text, 'info')
+  const choose = async <T>(title: string, items: T[], label: (item: T, index: number) => string) => {
+    const labels = items.map(label)
+    const selected = await host.ui.select(title, labels)
+    return selected === undefined ? undefined : items[labels.indexOf(selected)]
+  }
+  const completions = (): TerminalCommandCompletion[] => {
+    const session = host.session()
+    const commands = new Map(BUILTINS.map(command => [command.name, command]))
+    for (const command of session.extensionRunner.getRegisteredCommands()) {
+      if (!commands.has(command.name)) commands.set(command.name, { name: command.name, description: command.description })
+    }
+    for (const prompt of session.resourceLoader.getPrompts().prompts) {
+      if (!commands.has(prompt.name)) commands.set(prompt.name, { name: prompt.name, description: prompt.description })
+    }
+    if (session.settingsManager.getEnableSkillCommands()) {
+      for (const skill of session.resourceLoader.getSkills().skills) commands.set(`skill:${skill.name}`, { name: `skill:${skill.name}`, description: skill.description })
+    }
+    return [...commands.values()]
+  }
+
+  async function settings() {
+    const session = host.session()
+    const settings = session.settingsManager
+    const booleanSettings = [
+      ['Auto compaction', () => session.autoCompactionEnabled, (value: boolean) => session.setAutoCompactionEnabled(value)],
+      ['Auto retry', () => session.autoRetryEnabled, (value: boolean) => session.setAutoRetryEnabled(value)],
+      ['Show images', () => settings.getShowImages(), (value: boolean) => settings.setShowImages(value)],
+      ['Resize images', () => settings.getImageAutoResize(), (value: boolean) => settings.setImageAutoResize(value)],
+      ['Block images', () => settings.getBlockImages(), (value: boolean) => settings.setBlockImages(value)],
+      ['Skill commands', () => settings.getEnableSkillCommands(), (value: boolean) => settings.setEnableSkillCommands(value)],
+      ['Hide thinking', () => settings.getHideThinkingBlock(), (value: boolean) => settings.setHideThinkingBlock(value)],
+      ['Hardware cursor', () => settings.getShowHardwareCursor(), (value: boolean) => settings.setShowHardwareCursor(value)],
+      ['Terminal progress', () => settings.getShowTerminalProgress(), (value: boolean) => settings.setShowTerminalProgress(value)]
+    ] as const
+    let selectedId: string | undefined
+    const locations = [
+      ['Context', 'Compaction'], ['Model', 'Recovery'], ['Appearance', 'Images'], ['Appearance', 'Images'],
+      ['Context', 'Images'], ['Interaction', 'Commands'], ['Appearance', 'Display'], ['Interaction', 'Editor'],
+      ['Interaction', 'Terminal'], ['Model', 'Thinking'], ['Interaction', 'Queues'], ['Interaction', 'Queues'],
+      ['Appearance', 'Theme'], ['Interaction', 'Keyboard']
+    ]
+    for (;;) {
+      const options = [...booleanSettings.map(([label, get]) => `${label}: ${get() ? 'on' : 'off'}`),
+        `Thinking: ${session.thinkingLevel}`, `Steering: ${session.steeringMode}`, `Follow-up: ${session.followUpMode}`,
+        `Theme: ${host.ui.theme.name}`, 'Keyboard controls', 'Done']
+      const descriptions = [
+        'Compact the context automatically when the session approaches its limit.', 'Retry eligible provider failures automatically.',
+        'Display actual image content returned by tools.', 'Resize image attachments before provider requests.',
+        'Block image attachments in provider requests.', 'Expose commands for the skills loaded in this session.',
+        'Collapse assistant thinking blocks in the transcript.', 'Display the terminal hardware cursor for editing and input methods.',
+        'Report active work through supported terminal progress controls.', 'Reasoning effort for the current model.',
+        'Delivery mode for messages that steer an active run.', 'Delivery mode for messages queued after a run.',
+        'Theme loaded from the trusted resource catalog.', 'View the current application keyboard bindings.'
+      ]
+      const items: TerminalSettingItem[] = options.slice(0, -1).map((option, index) => {
+        const split = option.indexOf(':')
+        return { id: String(index), tab: locations[index][0], group: locations[index][1], label: split < 0 ? option : option.slice(0, split), value: split < 0 ? '' : option.slice(split + 1).trim(), description: descriptions[index] }
+      })
+      const groups = ['Theme', 'Display', 'Images', 'Thinking', 'Recovery', 'Editor', 'Queues', 'Commands', 'Terminal', 'Keyboard', 'Compaction']
+      items.sort((a, b) => groups.indexOf(a.group) - groups.indexOf(b.group))
+      const id = await host.ui.custom<string | undefined>((tui, theme, _keys, done) => new SettingsPanel(tui, () => theme, items, done, selectedId), { overlay: true, overlayOptions: { width: '100%', maxHeight: '100%', anchor: 'top-left' } })
+      if (id === undefined) return
+      selectedId = id
+      const index = Number(id)
+      const selected = options[index]
+      if (index < booleanSettings.length) {
+        const [, get, set] = booleanSettings[index]!
+        set(!get())
+      } else if (selected.startsWith('Thinking:')) {
+        const level = await host.ui.select('Thinking effort', session.getAvailableThinkingLevels())
+        if (level) session.setThinkingLevel(level as AgentSession['thinkingLevel'], { persist: true })
+      } else if (selected.startsWith('Steering:') || selected.startsWith('Follow-up:')) {
+        const mode = await host.ui.select('Queue delivery', ['all', 'one-at-a-time'])
+        if (mode === 'all' || mode === 'one-at-a-time') {
+          if (selected.startsWith('Steering:')) session.setSteeringMode(mode)
+          else session.setFollowUpMode(mode)
+        }
+      } else if (selected.startsWith('Theme:')) {
+        const theme = await host.ui.select('Theme', host.ui.getAllThemes().map(item => item.name))
+        if (theme) {
+          const result = host.ui.setTheme(theme)
+          if (!result.success) throw new Error(result.error)
+          settings.setTheme(theme)
+        }
+      } else notify(host.hotkeys?.() ?? 'Use /help for commands. Keyboard bindings are managed by the terminal application.')
+      host.refresh()
+    }
+  }
+
+  async function login(providerRef: string) {
+    const runtime = host.session().modelRuntime
+    const providers = runtime.getProviders().filter(provider => provider.auth.oauth || provider.auth.apiKey?.login)
+    const provider = providerRef
+      ? providers.find(item => item.id === providerRef || item.name.toLowerCase() === providerRef.toLowerCase())
+      : await choose('Sign in to provider', providers, item => `${item.name} (${item.id})`)
+    if (!provider) { if (providerRef) throw new Error(`No sign-in provider matches ${providerRef}`); return }
+    const types = [...(provider.auth.oauth ? ['oauth' as const] : []), ...(provider.auth.apiKey?.login ? ['api_key' as const] : [])]
+    const type = types.length === 1 ? types[0] : await host.ui.select('Authentication method', types)
+    if (type !== 'oauth' && type !== 'api_key') return
+    const deviceId = type === 'oauth' ? await host.runtime().installationDeviceId() : undefined
+    await runtime.login(provider.id, type, {
+      prompt: async prompt => {
+        let result: string | undefined
+        if (prompt.type === 'select') {
+          const option = await choose(prompt.message, [...prompt.options], item => item.label)
+          result = option?.id
+        } else if (prompt.type === 'secret') {
+          if (!host.secretInput) throw new Error('Secure credential entry is unavailable')
+          result = await host.secretInput(prompt.message, prompt.placeholder, { signal: prompt.signal })
+        } else result = await host.ui.input(prompt.message, prompt.placeholder, { signal: prompt.signal })
+        if (result === undefined) throw new Error('Sign-in cancelled')
+        return result
+      },
+      notify: event => {
+        if (event.type === 'auth_url') {
+          notify(`${event.instructions ?? 'Open this sign-in URL:'}\n${event.url}`)
+          void host.openExternal?.(event.url).catch(error => host.ui.notify(String(error), 'warning'))
+        } else if (event.type === 'device_code') notify(`${event.verificationUri}\nCode: ${event.userCode}`)
+        else notify(event.message)
+      }
+    }, deviceId ? { getDeviceId: () => deviceId } : undefined)
+    notify(`Signed in to ${provider.name}`)
+  }
+
+  async function share() {
+    if (!await host.ui.confirm('Share session', 'Upload the current session as a secret GitHub gist? Anyone with its link can read its contents.')) return
+    const directory = await mkdtemp(join(tmpdir(), 'harness-share-'))
+    try {
+      const path = await host.session().exportToHtml(join(directory, 'session.html'), { themeName: host.ui.theme.name })
+      const result = await promisify(execFile)('gh', ['gist', 'create', '--public=false', path], { timeout: 60_000, maxBuffer: 1024 * 1024 })
+      notify(`Session shared: ${result.stdout.trim()}`)
+    } finally { await rm(directory, { recursive: true, force: true }) }
+  }
+
+  async function execute(text: string): Promise<boolean> {
+    const match = /^\/([^\s]+)(?:\s+([\s\S]*))?$/.exec(text.trim())
+    if (!match) return false
+    const name = match[1]!
+    const argument = match[2]?.trim() ?? ''
+    if (!BUILTINS.some(item => item.name === name)) {
+      if (completions().some(item => item.name === name)) return false
+      host.ui.notify(`Unknown command: /${name}. Use /help to list commands.`, 'error')
+      return true
+    }
+    try {
+      const session = host.session()
+      switch (name) {
+        case 'help': notify(completions().map(item => `/${item.name}  ${item.description ?? ''}`).join('\n')); break
+        case 'quit': host.shutdown(); break
+        case 'new': await host.runtime().newSession(); break
+        case 'resume': {
+          let path = argument
+          if (!path) {
+            const sessions = await SessionManager.list(host.cwd(), host.sessionDirectory())
+            const selected = await choose('Resume session', sessions, (item, index) => `${index + 1}. ${item.name ?? item.firstMessage ?? item.id}  ${item.modified.toLocaleString()}`)
+            if (!selected) break
+            path = selected.path
+          }
+          const target = resolve(host.cwd(), path)
+          const within = relative(host.sessionDirectory(), target)
+          if (within === '..' || within.startsWith('../') || within.startsWith('..\\') || isAbsolute(within)) {
+            throw new Error('Resume sessions from this account history folder. Use /import to explicitly import a session.')
+          }
+          await host.runtime().switchSession(target)
+          break
+        }
+        case 'fork': {
+          const message = await choose('Fork before message', session.getUserMessagesForForking(), (item, index) => `${index + 1}. ${item.text.replace(/\s+/g, ' ').slice(0, 160)}`)
+          if (message) {
+            const result = await host.runtime().fork(message.entryId)
+            if (!result.cancelled && result.selectedText) host.setEditorText(result.selectedText)
+          }
+          break
+        }
+        case 'clone': {
+          const leaf = session.sessionManager.getLeafId()
+          if (!leaf) throw new Error('Nothing to clone yet')
+          const result = await host.runtime().fork(leaf, { position: 'at' })
+          if (!result.cancelled) { host.setEditorText(''); notify('Cloned to new session') }
+          break
+        }
+        case 'tree': {
+          const tree = session.sessionManager.getTree()
+          if (!tree.length) throw new Error('No entries in this session')
+          const selected = await host.ui.custom<string | undefined>((tui, _theme, _keys, done) => {
+            const selector = new TreeSelectorComponent(tree, session.sessionManager.getLeafId(), tui.terminal.rows,
+              done, () => done(undefined), (entryId, label) => session.sessionManager.appendLabelChange(entryId, label),
+              undefined, session.settingsManager.getTreeFilterMode())
+            selector.onCopy = text => { if (text) void host.copyText(text).catch(error => host.ui.notify(String(error), 'error')) }
+            return selector
+          })
+          if (selected && selected !== session.sessionManager.getLeafId()) {
+            const summarize = await host.ui.confirm('Navigate session', 'Summarize the abandoned branch before navigating?')
+            const result = await host.runtime().navigateTree(selected, { summarize })
+            if (!result.cancelled && result.editorText) host.setEditorText(result.editorText)
+          }
+          break
+        }
+        case 'thinking': {
+          const levels = session.getAvailableThinkingLevels()
+          const level = argument || await host.ui.select('Thinking effort', levels)
+          if (!level) break
+          if (!levels.includes(level as AgentSession['thinkingLevel'])) throw new Error(`Available thinking levels: ${levels.join(', ')}`)
+          session.setThinkingLevel(level as AgentSession['thinkingLevel'], { persist: true })
+          break
+        }
+        case 'model': {
+          const provider = session.settingsManager.getDefaultProvider()
+          const id = session.settingsManager.getDefaultModel()
+          const selected = await host.ui.custom<{ model: NonNullable<AgentSession['model']>; persist: boolean } | undefined>((tui, _theme, _keys, done) =>
+            new ModelSelectorComponent(tui, session.model, session.modelRuntime, session.scopedModels,
+              model => done({ model, persist: false }), () => done(undefined), argument || undefined,
+              model => done({ model, persist: true }), provider && id ? { provider, id } : undefined))
+          if (selected) await session.setModel(selected.model, { persist: selected.persist })
+          break
+        }
+        case 'scoped-models': {
+          const models = await session.modelRuntime.getAvailable()
+          const selected = new Set(session.scopedModels.map(item => `${item.model.provider}/${item.model.id}`))
+          for (;;) {
+            const labels = models.map(model => `${selected.has(`${model.provider}/${model.id}`) ? '☑' : '☐'} ${model.provider}/${model.id}`)
+            const choice = await host.ui.select('Models for cycling', [...labels, 'Save', 'Cancel'])
+            if (!choice || choice === 'Cancel') break
+            if (choice === 'Save') {
+              session.setScopedModels(models.filter(model => selected.has(`${model.provider}/${model.id}`)).map(model => ({ model })))
+              session.settingsManager.setEnabledModels([...selected])
+              break
+            }
+            const model = models[labels.indexOf(choice)]
+            if (model) { const key = `${model.provider}/${model.id}`; if (selected.has(key)) selected.delete(key); else selected.add(key) }
+          }
+          break
+        }
+        case 'settings': await settings(); break
+        case 'name': {
+          const name = argument || await host.ui.input('Session name', session.sessionName)
+          if (name !== undefined) session.setSessionName(name)
+          break
+        }
+        case 'session': notify(JSON.stringify(session.getSessionStats(), null, 2)); break
+        case 'compact': await session.compact(argument || undefined); break
+        case 'reload': await host.runtime().reload(); notify('Trusted resources reloaded'); break
+        case 'trust': {
+          if (!session.extensionRunner.getRegisteredCommands().some(command => command.name === 'plugins')) throw new Error('Plugin trust controls are unavailable in this session.')
+          await session.prompt('/plugins')
+          break
+        }
+        case 'bug': {
+          const description = argument || await host.ui.input('Describe the Harness issue')
+          if (!description) break
+          const repository = manifest.repository.url.replace(/^git\+/, '').replace(/\.git$/, '')
+          const url = new URL(`${repository}/issues/new`)
+          url.searchParams.set('title', description.split('\n')[0]!.slice(0, 120))
+          url.searchParams.set('body', `${description}\n\nHarness ${manifest.version} · ${process.platform} ${process.arch} · Node ${process.version}`)
+          if (!host.openExternal) throw new Error(`Open the issue draft: ${url}`)
+          if (await host.ui.confirm('Open issue draft?', `${description}\n\nOpen the Harness issue form in your browser to review and submit.`)) await host.openExternal(url.href)
+          break
+        }
+        case 'login': await login(argument); break
+        case 'logout': {
+          const credentials = await session.modelRuntime.listCredentials()
+          const provider = argument || await host.ui.select('Sign out of provider', credentials.map(item => item.providerId))
+          if (provider && await host.ui.confirm('Sign out', `Remove the stored credential for ${provider} from this account?`)) {
+            await session.modelRuntime.logout(provider)
+            notify(`Signed out of ${provider}`)
+          }
+          break
+        }
+        case 'copy': {
+          const response = session.getLastAssistantText()
+          if (!response) throw new Error('No assistant response to copy yet')
+          await host.copyText(response)
+          notify('Copied last assistant response')
+          break
+        }
+        case 'export': {
+          const output = argument || await host.ui.input('Export path (.html or .jsonl)', 'session.html')
+          if (!output) break
+          const path = resolve(host.cwd(), output)
+          notify(`Exported to ${path.endsWith('.jsonl') ? session.exportToJsonl(path) : await session.exportToHtml(path, { themeName: host.ui.theme.name })}`)
+          break
+        }
+        case 'import': {
+          const input = argument || await host.ui.input('Import session JSONL path')
+          if (input) await host.runtime().importFromJsonl(resolve(host.cwd(), input))
+          break
+        }
+        case 'share': await share(); break
+        case 'hotkeys': notify(host.hotkeys?.() ?? 'Keyboard bindings are managed by the terminal application.'); break
+        case 'changelog': {
+          if (!host.changelog) throw new Error('No Harness release notes are installed')
+          notify(await host.changelog())
+          break
+        }
+      }
+      host.refresh()
+    } catch (error) { host.ui.notify(error instanceof Error ? error.message : String(error), 'error') }
+    return true
+  }
+  return { execute, completions }
+}