import type { Register, EngineInterface, Timer } from 'claude-code'

import {
  bar,
  buildProgress,
  changedPaths,
  defaultTab,
  issueOfBranch,
  joinPath,
  manualTasks,
  parseDecisions,
  parseFindings,
  parseLedger,
  parsePlan,
  parseWorktrees,
  stageOf,
  statusNote,
  TABS,
  worktreeOf,
  wrapFocus,
} from './parse.ts'
import type { Decision, Doc, Findings, Ledger, Plan, Progress, Stage, Tab, TaskView, Worktree } from './parse.ts'

const PANE = 'feature'
// /feature may be taken by a built-in or another plugin; fall back to the next free name
const NAMES = ['feature', 'progress', 'feature-pane']
const PLANS_DIR = 'docs/superpowers/plans'
const SDD_DIR = '.superpowers/sdd'
// SDD runs in a background subagent, so its edits do not always pass through this session's tool calls
const POLL_MS = 15_000

type Ruling = Decision & { marker?: string; path: string }

/** One thing to show: a plan in a worktree, or a worktree with no plan (a bounded branch). */
type Target = {
  key: string
  worktree: Worktree
  issue?: number
  changes: string[]
  bounded: boolean
  commits: string[]
  pushed: boolean
  planPath?: string
  plan?: Plan
  ledger?: Ledger
  ledgerPath?: string
  progress?: Progress
  findings?: Findings
  rulings: Ruling[]
  docs: Doc[]
  stage: Stage
  activityMs: number
}


// Module state: rebuilt from git and disk on every open, refresh and edit, so a reload loses nothing
let commandName = ''
let targets: Target[] = []
let selected: string | undefined
let hideDone = false
// Раскрытые задачи по каждому плану (ключ Target); плана нет в карте — раскрыта следующая задача
const expanded = new Map<string, Set<number>>()
// Выбранная вкладка по каждому Target; нет в карте — по этапу
const tabs = new Map<string, Tab>()
// Раскрытые рулинги (номер решения) и находки (маркер) по каждому Target
const openRulings = new Map<string, Set<number>>()
const openFindings = new Map<string, Set<string>>()
let isOpen = false
let loaded = false
let error = ''
let loading: Promise<void> | undefined
let poll: Timer | undefined
// Строки списка в порядке отрисовки и последняя строка с фокусом: стрелки ходят только по ним
let rows: string[] = []
let lastRow: string | undefined
// Команда просмотрщика: glow, если он есть, иначе less; ищется один раз
let viewerCmd: string | undefined

async function git($: EngineInterface, cwd: string, args: string[]): Promise<string | undefined> {
  try {
    const r = await $.process.run(['git', ...args], { cwd, timeoutMs: 10_000 })
    return r.exitCode === 0 ? r.stdout : undefined
  } catch {
    return undefined
  }
}

async function readText($: EngineInterface, path: string): Promise<string | undefined> {
  try {
    return await $.fs.read(path)
  } catch {
    // Missing, or mid-write: skip it this round
    return undefined
  }
}

async function mtime($: EngineInterface, path: string): Promise<number> {
  try {
    return (await $.fs.stat(path)).mtimeMs
  } catch {
    return 0
  }
}

async function dirs($: EngineInterface, path: string): Promise<string[]> {
  try {
    return (await $.fs.list(path)).filter(e => e.kind === 'dir').map(e => e.name)
  } catch {
    return []
  }
}

async function exists($: EngineInterface, path: string): Promise<boolean> {
  try {
    return await $.fs.exists(path)
  } catch {
    return false
  }
}

async function viewer($: EngineInterface): Promise<string> {
  if (viewerCmd) return viewerCmd
  let glow: string | undefined
  try {
    const r = await $.process.run(['/usr/bin/which', 'glow'], { timeoutMs: 5_000 })
    if (r.exitCode === 0) glow = r.stdout.trim() || undefined
  } catch {
    // which itself missing: try the usual places
  }
  for (const p of ['/opt/homebrew/bin/glow', '/usr/local/bin/glow']) {
    if (!glow && (await exists($, p))) glow = p
  }
  viewerCmd = glow ? `${glow} -t` : '/usr/bin/less'
  return viewerCmd
}

/**
 * Открыть документ в терминальном просмотрщике рядом с сессией. Свой терминал у мода
 * не интерактивный (вывод уходит в пайп), поэтому — соседняя панель iTerm или окно Terminal.
 */
async function openDoc($: EngineInterface, path: string): Promise<void> {
  const term = await $.env.get('TERM_PROGRAM')
  const cmd = await viewer($)
  const script =
    term === 'iTerm.app'
      ? 'tell application "iTerm2" to tell current session of current window to split vertically with default profile command ((item 1 of argv) & " " & quoted form of (item 2 of argv))'
      : term === 'Apple_Terminal'
        ? 'tell application "Terminal"\nactivate\ndo script ((item 1 of argv) & " " & quoted form of (item 2 of argv))\nend tell'
        : undefined
  try {
    const r = script
      ? await $.process.run(['osascript', '-e', 'on run argv', '-e', script, '-e', 'end run', cmd, path], {
          timeoutMs: 10_000,
        })
      : await $.process.run(['open', path], { timeoutMs: 10_000 })
    if (r.exitCode !== 0) $.ui.toast(`Не открылось: ${r.stderr.trim() || 'код ' + r.exitCode}`)
  } catch (err) {
    $.ui.toast(`Не открылось: ${err instanceof Error ? err.message : String(err)}`)
  }
}

const CHANGE_DOCS: [file: string, label: string][] = [
  ['proposal', 'Proposal — зачем фича и что меняется'],
  ['design', 'Design — устройство и решения без обсуждения'],
]

/** Документы change: proposal, design, спеки capability. README — только указатель, его нет. */
async function changeDocs($: EngineInterface, wt: string, name: string, several: boolean): Promise<Doc[]> {
  const dir = joinPath(wt, `openspec/changes/${name}`)
  // Несколько change в одной ветке — подписи различает имя change
  const of = several ? ` (${name})` : ''
  const docs: Doc[] = []
  for (const [file, label] of CHANGE_DOCS) {
    if (await exists($, `${dir}/${file}.md`)) docs.push({ label: label + of, path: `${dir}/${file}.md` })
  }
  for (const cap of await dirs($, `${dir}/specs`)) {
    if (await exists($, `${dir}/specs/${cap}/spec.md`)) {
      docs.push({ label: `Спека ${cap} — требования и сценарии${of}`, path: `${dir}/specs/${cap}/spec.md` })
    }
  }
  return docs
}

async function loadWorktree($: EngineInterface, wt: Worktree, base: string | undefined): Promise<Target[]> {
  const onBase = !wt.branch || wt.branch === base
  const changes = (await dirs($, joinPath(wt.path, 'openspec/changes'))).filter(n => n !== 'archive')
  const bounded = await exists($, joinPath(wt.path, '.bounded'))
  const log = !onBase && base ? await git($, wt.path, ['log', '--format=%h %s', '-n', '8', `${base}..HEAD`]) : ''
  const commits = (log ?? '').split(/\r?\n/).filter(Boolean)
  // На сервере и ничего не осталось непушнутым
  const ahead = onBase ? undefined : await git($, wt.path, ['rev-list', '--count', '@{u}..HEAD'])
  const pushed = ahead !== undefined && ahead.trim() === '0'

  const changeDocsList: Doc[] = []
  const decisions: { d: Decision; path: string }[] = []
  for (const name of changes) {
    changeDocsList.push(...(await changeDocs($, wt.path, name, changes.length > 1)))
    const designPath = joinPath(wt.path, `openspec/changes/${name}/design.md`)
    const design = await readText($, designPath)
    if (design) decisions.push(...parseDecisions(design).map(d => ({ d, path: designPath })))
  }

  // Plans SDD runs on, else the plans this branch adds or changes
  const runs: { planRel: string; ledger?: Ledger; ledgerText?: string; ledgerPath?: string; ledgerMs: number }[] = []
  for (const name of await dirs($, joinPath(wt.path, SDD_DIR))) {
    const ws = joinPath(wt.path, `${SDD_DIR}/${name}`)
    const text = await readText($, ws + '/progress.md')
    const ledger = text === undefined ? undefined : parseLedger(text)
    const marker = (await readText($, ws + '/plan-path'))?.trim()
    const planRel = marker || ledger?.plan || `${PLANS_DIR}/${name}.md`
    runs.push({
      planRel,
      ledger,
      ledgerText: text,
      ledgerPath: text === undefined ? undefined : ws + '/progress.md',
      ledgerMs: await mtime($, ws + '/progress.md'),
    })
  }
  if (runs.length === 0) {
    const diff = !onBase && base ? await git($, wt.path, ['diff', '--name-only', `${base}...HEAD`, '--', PLANS_DIR]) : ''
    const status = await git($, wt.path, ['status', '--porcelain', '--untracked-files=all', '--', PLANS_DIR])
    for (const rel of changedPaths(diff ?? '', status ?? '')) {
      if (rel.endsWith('.md')) runs.push({ planRel: rel, ledgerMs: 0 })
    }
  }

  const common = { worktree: wt, changes, bounded, commits, pushed }
  const rulingsFor = (ledger?: Ledger): Ruling[] =>
    decisions
      // Решения, выбранные человеком, смотреть не нужно
      .filter(x => !x.d.human)
      .map(x => ({ ...x.d, marker: ledger?.rulingOf.get(x.d.n), path: x.path }))

  if (runs.length === 0) {
    // The main checkout with nothing in flight is not worth a row
    if (onBase && changes.length === 0 && !bounded) return []
    const stage = stageOf({ change: changes.length > 0, bounded, manual: [], pushed, commits: commits.length })
    return [
      {
        key: wt.path,
        issue: issueOfBranch(wt.branch),
        ...common,
        rulings: rulingsFor(),
        docs: changeDocsList,
        stage,
        activityMs: 0,
      },
    ]
  }

  const out: Target[] = []
  for (const run of runs) {
    const planPath = joinPath(wt.path, run.planRel)
    const text = await readText($, planPath)
    const plan = text === undefined ? undefined : parsePlan(run.planRel, text)
    const progress = plan ? buildProgress(plan, run.ledger) : undefined
    const docs = [...changeDocsList]
    if (plan) docs.push({ label: `План — ${plan.title || run.planRel}`, path: planPath })
    if (run.ledgerPath) docs.push({ label: 'SDD ledger — ход исполнения и находки', path: run.ledgerPath })
    out.push({
      key: wt.path + '::' + run.planRel,
      issue: plan?.issue ?? issueOfBranch(wt.branch),
      ...common,
      planPath: run.planRel,
      plan,
      ledger: run.ledger,
      ledgerPath: run.ledgerPath,
      progress,
      findings: run.ledgerText === undefined ? undefined : parseFindings(run.ledgerText),
      rulings: rulingsFor(run.ledger),
      docs,
      stage: stageOf({
        change: changes.length > 0,
        bounded,
        planPath: run.planRel,
        progress,
        ledger: run.ledger,
        manual: manualTasks(plan, run.ledger),
        pushed,
        commits: commits.length,
      }),
      activityMs: Math.max(run.ledgerMs, await mtime($, planPath)),
    })
  }
  return out
}

/** Default: the session's own worktree, its most active plan; else the most active plan anywhere. */
function defaultKey(worktrees: Worktree[], root: string): string | undefined {
  const own = worktreeOf(worktrees, root)
  const byActivity = [...targets].sort((a, b) => b.activityMs - a.activityMs)
  const mine = byActivity.filter(t => t.worktree.path === own?.path)
  return (mine[0] ?? byActivity.find(t => t.progress) ?? byActivity[0])?.key
}

async function load($: EngineInterface): Promise<void> {
  const root = await $.session.root()
  const listing = await git($, root, ['worktree', 'list', '--porcelain'])
  const worktrees = listing ? parseWorktrees(listing) : [{ path: root }]
  const base =
    (await git($, root, ['rev-parse', '--verify', '--quiet', 'refs/heads/main'])) !== undefined
      ? 'main'
      : (await git($, root, ['rev-parse', '--verify', '--quiet', 'refs/heads/master'])) !== undefined
        ? 'master'
        : undefined

  targets = (await Promise.all(worktrees.map(w => loadWorktree($, w, base)))).flat()
  loaded = true
  error = targets.length === 0 ? 'Нет веток в работе: ни планов, ни SDD-ledger, ни OpenSpec change' : ''
  if (!selected || !targets.some(t => t.key === selected)) selected = defaultKey(worktrees, root)
}

async function refresh($: EngineInterface): Promise<void> {
  if (!loading) {
    loading = load($).finally(() => {
      loading = undefined
    })
  }
  await loading
  $.ui.invalidate('ui.render')
}

type RowStyle = { dimColor?: boolean; bold?: boolean; color?: 'suggestion' | 'success' | 'warning' }

function expandedFor(key: string, p: Progress): Set<number> {
  let set = expanded.get(key)
  if (!set) {
    set = new Set(p.next ? [p.next.n] : [])
    expanded.set(key, set)
  }
  return set
}

/** Выбор человека запоминается по каждой ветке; иначе — вкладка этапа. */
function tabFor(t: Target): Tab {
  return (
    tabs.get(t.key) ??
    defaultTab({
      progress: t.progress,
      ledger: t.ledger,
      docs: t.docs.length,
      rulings: t.rulings.length,
      boundedNoPlan: t.bounded && !t.planPath,
      pushed: t.pushed,
    })
  )
}

function startPolling($: EngineInterface): void {
  if (poll) return
  poll = $.clock.every(POLL_MS, () => {
    if (isOpen) void refresh($)
  })
}

function stopPolling(): void {
  poll?.cancel()
  poll = undefined
}

function touchesProgress(path: unknown): boolean {
  return (
    typeof path === 'string' &&
    /(\.superpowers\/sdd\/|docs\/superpowers\/plans\/|openspec\/changes\/|\/\.bounded$)/.test(path)
  )
}

function branchName(wt: Worktree): string {
  return wt.branch ?? (wt.path.split('/').pop() || wt.path) + ' (detached)'
}

function targetLabel(t: Target, plansInWorktree: number): string {
  const plan = plansInWorktree > 1 && t.planPath ? '  ' + (t.planPath.split('/').pop() ?? '') : ''
  const state = t.progress
    ? `${t.progress.done}/${t.progress.total}`
    : t.planPath
      ? 'план не найден'
      : t.bounded
        ? 'bounded'
        : 'без плана'
  return `${branchName(t.worktree)}${plan}  ${state}`
}

function pick(wanted: string): Target | undefined {
  const w = wanted.replace(/^#/, '')
  return (
    targets.find(t => t.worktree.branch === w) ??
    targets.find(t => String(t.issue) === w) ??
    targets.find(t => (t.worktree.branch ?? '').includes(w) || (t.planPath ?? '').includes(w))
  )
}

function setOf<T>(map: Map<string, Set<T>>, key: string): Set<T> {
  let set = map.get(key)
  if (!set) {
    set = new Set<T>()
    map.set(key, set)
  }
  return set
}

export const register: Register = on => {
  on('session.start', async ($, e, next) => {
    for (const name of NAMES) {
      try {
        const { command } = await $.command.register({
          name,
          description: 'Фича по веткам: этап и чей ход, задачи плана, рулинги, отложенное, документы',
          argumentHint: '[ветка | issue | план]',
          immediate: true,
        })
        commandName = command
        break
      } catch {
        // Name taken, try the next one
      }
    }
    return next(e)
  })

  on('command.run', async ($, e, next) => {
    if (!commandName || e.command !== commandName) return next(e)
    const wanted = (e.args ?? '').trim()
    await load($)
    if (wanted) selected = pick(wanted)?.key ?? selected
    isOpen = true
    startPolling($)
    await $.ui.open({ id: PANE, title: 'Фича', focus: true, closeOnEscape: true })
    return {}
  })

  on('ui.close', async ($, e, next) => {
    if (e.id === PANE) {
      isOpen = false
      stopPolling()
    }
    return next(e)
  })

  // Стрелки и Tab ходят по кругу только по строкам списка; кнопки и ветки — по своим клавишам
  on('ui.focus', { requestId: PANE }, async ($, e, next) => {
    const el = e.element
    if (el && rows.includes(el)) {
      lastRow = el
      return next(e)
    }
    const target = e.origin.kind === 'person' ? wrapFocus(rows, lastRow) : undefined
    if (!target) return next(e)
    lastRow = target
    return next({ ...e, element: target })
  })

  // Live refresh while plans, ledgers and changes are edited in this session
  on('tool.call', async ($, e, next) => {
    const result = await next(e)
    if (!isOpen) return result
    const touched =
      touchesProgress((e as { file_path?: unknown }).file_path) ||
      e.tool === 'Agent' ||
      (e.tool === 'Bash' &&
        /\bgit\b|openspec|superpowers|\.bounded/.test(String((e as { command?: unknown }).command ?? '')))
    if (touched) await refresh($)
    return result
  })

  // And once more at the end of every turn, to catch anything else
  on('turn.complete', async ($, e, next) => {
    const result = await next(e)
    if (isOpen) await refresh($)
    return result
  })

  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
    // Only an open pane is drawn: after a reload this is how the module learns it is open
    isOpen = true
    startPolling($)
    if (!loaded) void refresh($)

    const els = $.ui.resolve(e)
    const { Box, Text, Button } = els
    const columns = Math.max(30, e.props.bodyColumns ?? 60)

    const refreshButton = (
      <Button key="refresh" label="обновить" hotkey="r" plain dimColor onPress={() => void refresh($)} />
    )

    if (!loaded || targets.length === 0) {
      rows = []
      return (
        <Box flexDirection="column">
          <Text dimColor>{loaded ? error : 'Загрузка…'}</Text>
          {refreshButton}
        </Box>
      )
    }

    const t = targets.find(x => x.key === selected) ?? (targets[0] as Target)
    const redraw = () => $.ui.invalidate('ui.render')
    const choose = (key: string) => {
      selected = key
      redraw()
    }
    const plansIn = (wt: Worktree) => targets.filter(x => x.worktree.path === wt.path).length
    // 9 / 0 — по кругу по всем веткам; цифры работают в любой раскладке
    const step = (by: number) => {
      const i = targets.findIndex(x => x.key === t.key)
      const next = targets[(i + by + targets.length) % targets.length]
      if (next) choose(next.key)
    }
    const branchButtons =
      targets.length > 1
        ? [
            // Порядок как на клавиатуре и в карусели: 9 — влево, 0 — вправо
            <Button key="prev-branch" label="‹ ветка" hotkey="9" plain dimColor onPress={() => step(-1)} />,
            <Button key="next-branch" label="ветка ›" hotkey="0" plain dimColor onPress={() => step(1)} />,
          ]
        : []

    // Ветки — карусель: 9 / 0 внизу листают по кругу. Не Select: он забирает стрелки у списка
    const index = targets.findIndex(x => x.key === t.key)
    const picker =
      targets.length > 1 ? (
        <Box flexDirection="row" columnGap={1}>
          <Text dimColor>‹</Text>
          <Text bold wrap="truncate-end">
            {targetLabel(t, plansIn(t.worktree))}
          </Text>
          <Text dimColor>›</Text>
        </Box>
      ) : (
        <Text bold wrap="truncate-end">
          {branchName(t.worktree)}
        </Text>
      )

    const meta = [
      t.issue !== undefined ? '#' + t.issue : undefined,
      t.changes.length ? 'openspec: ' + t.changes.join(', ') : undefined,
      t.bounded ? 'bounded' : undefined,
      t.progress
        ? t.progress.source === 'ledger'
          ? 'по SDD-ledger'
          : t.progress.anyTicked
            ? 'по шагам плана'
            : 'SDD не запущен'
        : undefined,
    ].filter(Boolean)

    const yours = t.stage.who === 'you'
    // Шапка по центру панели
    const head = (
      <Box flexDirection="column" alignItems="center">
        {picker}
        {/* Точки под каруселью: по одной на ветку, текущая — закрашена */}
        {targets.length > 1 && (
          <Box flexDirection="row" columnGap={1}>
            {targets.map((x, i) => (
              <Text key={'dot-' + i} dimColor={i !== index}>
                {i === index ? '●' : '○'}
              </Text>
            ))}
          </Box>
        )}
        {meta.length > 0 && (
          <Text dimColor wrap="truncate-end">
            {meta.join(' · ')}
          </Text>
        )}
        <Box flexDirection="row" columnGap={2}>
          <Text bold wrap="truncate-end">{`Этап: ${t.stage.label}`}</Text>
          <Text color={yours ? 'warning' : undefined} dimColor={!yours} bold={yours}>
            {yours ? 'ход за тобой' : 'работает агент'}
          </Text>
        </Box>
      </Box>
    )

    // Висячий отступ: префикс — колонка постоянной ширины, текст переносится в своей колонке
    const hang = (key: string, prefix: string, body: JSX.Element, prefixProps: RowStyle = {}) => (
      <Box key={key} flexDirection="row">
        <Box flexShrink={0}>
          <Text {...prefixProps}>{prefix}</Text>
        </Box>
        <Box flexGrow={1} flexShrink={1}>
          {body}
        </Box>
      </Box>
    )

    const tab = tabFor(t)
    const setTab = (next: Tab) => {
      tabs.set(t.key, next)
      redraw()
    }
    const focusRows: string[] = []
    const body: JSX.Element[] = []
    const empty = (text: string) => body.push(<Text key="empty" dimColor>{text}</Text>)

    const p = t.progress
    const f = t.findings
    const deferred = f?.items.filter(i => i.status === 'deferred') ?? []
    const openItems = f?.items.filter(i => i.status === 'open') ?? []

    // ── 1. Документы: Enter открывает файл в просмотрщике рядом с сессией
    if (tab === 'docs') {
      if (!t.docs.length) empty('Документов нет: ни OpenSpec change, ни плана')
      // Маркированный список; перенос длинной подписи — под текст, не под маркер
      t.docs.forEach((d, i) => {
        focusRows.push('doc-' + d.path)
        body.push(
          hang(
            'd' + d.path,
            '•  ',
            <Button key={'doc-' + d.path} plain autoFocus={i === 0 || undefined} onPress={() => void openDoc($, d.path)}>
              <Text wrap="wrap">{d.label}</Text>
            </Button>,
            { dimColor: true },
          ),
        )
      })
    }

    // ── 2. Задачи
    if (tab === 'tasks' && p) {
      const pct = p.total ? Math.round((p.done / p.total) * 100) : 0
      const wide = Math.max(4, Math.min(30, columns - 24))
      // Счётчики шагов — только если план кто-то отмечает: SDD шаги не отмечает
      const bySteps = p.source === 'steps' && p.anyTicked
      const open = expandedFor(t.key, p)
      const toggle = (n: number) => {
        if (open.has(n)) open.delete(n)
        else open.add(n)
        redraw()
      }
      body.push(
        <Text key="plan" bold wrap="truncate-end">
          {t.plan?.title || t.planPath}
        </Text>,
        <Box key="bar" flexDirection="row" columnGap={1}>
          <Text color={pct === 100 ? 'success' : 'suggestion'}>{bar(p.done, p.total, wide)}</Text>
          <Text bold>{`${p.done}/${p.total}`}</Text>
          <Text dimColor>{`задач · ${pct}%`}</Text>
        </Box>,
        <Text key="next" wrap="truncate-end" color={p.next ? 'suggestion' : 'success'}>
          {p.next ? `Дальше: Task ${p.next.n} — ${p.next.title}` : 'Все задачи выполнены'}
        </Text>,
        <Text key="gap"> </Text>,
      )
      const shown = hideDone ? p.tasks.filter(x => x.status !== 'done') : p.tasks
      const hidden = p.tasks.length - shown.length
      if (hidden > 0) body.push(<Text key="hidden" dimColor>{`✓ скрыто готовых: ${hidden}`}</Text>)

      shown.forEach((task: TaskView, index) => {
        const isNext = task === p.next
        const isOpenTask = open.has(task.n)
        // Статус: ✓ готово, ● в работе или следующая, ○ не начата. Раскрытие — отдельно: + / −
        const mark = task.status === 'done' ? '✓' : isNext || task.status === 'active' ? '●' : '○'
        const steps = bySteps ? (task.stepsTotal ? `${task.stepsDone}/${task.stepsTotal}` : '').padStart(5) + ' ' : ''
        const style: RowStyle = {
          dimColor: task.status === 'done',
          bold: isNext,
          color: isNext ? 'suggestion' : task.status === 'done' ? 'success' : undefined,
        }
        const prefix = `${task.steps.length ? (isOpenTask ? '−' : '+') : ' '} ${mark} ${steps}${String(task.n).padStart(2)}. `
        focusRows.push('task-' + task.n)
        body.push(
          hang(
            't' + task.n,
            prefix,
            <Button
              key={'task-' + task.n}
              plain
              autoFocus={isNext || (!p.next && index === 0) || undefined}
              onPress={() => toggle(task.n)}
            >
              <Text {...style} wrap="wrap">
                {task.title}
              </Text>
            </Button>,
            style,
          ),
        )
        const indent = ' '.repeat(prefix.length)
        if (task.note) {
          body.push(hang('n' + task.n, indent, <Text dimColor wrap="wrap">{task.note}</Text>, { dimColor: true }))
        }
        if (!isOpenTask) return
        task.steps.forEach((s, i) => {
          // SDD отмечает готовность задачи в ledger, не шаги: у готовой задачи готовы и шаги
          const done = s.done || (p.source === 'ledger' && task.status === 'done')
          focusRows.push(`step-${task.n}-${i}`)
          body.push(
            hang(
              `s${task.n}-${i}`,
              indent + '  '.repeat(s.depth) + (done ? '✓ ' : '· '),
              // Enter на шаге сворачивает задачу и возвращает на неё фокус
              <Button
                key={`step-${task.n}-${i}`}
                plain
                onPress={() => {
                  open.delete(task.n)
                  redraw()
                  void $.ui.focus({ requestId: PANE, key: 'task-' + task.n }).catch(() => {})
                }}
              >
                <Text dimColor={done} wrap="wrap">
                  {s.text}
                </Text>
              </Button>,
              { dimColor: done },
            ),
          )
        })
      })
    }

    // Без плана на вкладке задач — что уже в ветке
    if (tab === 'tasks' && !p) {
      if (t.planPath) body.push(<Text key="noplan" color="warning">{'План не найден: ' + t.planPath}</Text>)
      else empty(t.bounded ? 'Bounded-задача, плана нет' : 'Плана нет')
      body.push(
        <Text key="commits-h" dimColor>
          {t.commits.length
            ? `Коммиты в ветке (${t.commits.length}${t.commits.length === 8 ? '+' : ''}):`
            : 'Коммитов поверх main нет'}
        </Text>,
      )
      t.commits.forEach((c, i) =>
        body.push(
          <Text key={'c' + i} wrap="truncate-end">
            {'  ' + c}
          </Text>,
        ),
      )
    }

    // ── 3. Рулинги: решения без обсуждения из design.md, кроме выбранных человеком
    if (tab === 'rulings') {
      if (!t.rulings.length) empty('Решений без обсуждения нет')
      const open = setOf(openRulings, t.key)
      t.rulings.forEach((r, i) => {
        const isOpenRuling = open.has(r.n)
        const more = Boolean(r.why || r.cost)
        const prefix = `${more ? (isOpenRuling ? '−' : '+') : ' '} ${(r.marker ?? '').padEnd(4)} #${String(r.n).padEnd(3)}`
        focusRows.push('rul-' + r.n)
        body.push(
          hang(
            'r' + r.n,
            prefix,
            // Enter раскрывает обоснование и цену ошибки прямо в списке
            <Button
              key={'rul-' + r.n}
              plain
              autoFocus={i === 0 || undefined}
              onPress={() => {
                if (isOpenRuling) open.delete(r.n)
                else if (more) open.add(r.n)
                redraw()
              }}
            >
              <Text wrap="wrap">{r.stage ? `${r.text} (${r.stage})` : r.text}</Text>
            </Button>,
            { color: r.marker ? 'suggestion' : undefined, dimColor: !r.marker },
          ),
        )
        if (!isOpenRuling) return
        const indent = ' '.repeat(prefix.length)
        if (r.why) body.push(hang('rw' + r.n, indent, <Text dimColor wrap="wrap">{'Почему: ' + r.why}</Text>))
        if (r.cost) body.push(hang('rc' + r.n, indent, <Text dimColor wrap="wrap">{'Цена ошибки: ' + r.cost}</Text>))
      })
    }

    // ── 4. Отложено: открытые находки первыми, затем deferred
    if (tab === 'deferred') {
      if (!f) empty('SDD-ledger нет: находок пока нет')
      else if (!deferred.length && !openItems.length) empty('Отложенного нет')
      else
        body.push(
          <Text key="hint" dimColor>
            {f.final ? 'по таблице ## Findings в ledger' : 'предварительно, по строкам ledger: таблицы ## Findings ещё нет'}
          </Text>,
        )
      const open = setOf(openFindings, t.key)
      ;[...openItems, ...deferred].forEach((item, i) => {
        const isOpenItem = item.status === 'open'
        // Пояснение к статусу — то, что сверх самого слова: `deferred (решит Task 7, шаг 3)`
        const note = statusNote(item.detail)
        const isOpenNote = open.has(item.marker)
        const prefix = `${note ? (isOpenNote ? '−' : '+') : ' '} ${isOpenItem ? '!' : '·'} ${item.marker.padEnd(7)}`
        focusRows.push('find-' + item.marker)
        body.push(
          hang(
            'f' + item.marker,
            prefix,
            // Enter раскрывает пояснение к статусу, если оно есть
            <Button
              key={'find-' + item.marker}
              plain
              autoFocus={i === 0 || undefined}
              onPress={() => {
                if (isOpenNote) open.delete(item.marker)
                else if (note) open.add(item.marker)
                redraw()
              }}
            >
              <Text wrap="wrap">{item.text || item.detail || '—'}</Text>
            </Button>,
            { color: isOpenItem ? 'warning' : undefined, bold: isOpenItem },
          ),
        )
        if (isOpenNote) {
          body.push(hang('fn' + item.marker, ' '.repeat(prefix.length), <Text dimColor wrap="wrap">{note}</Text>))
        }
      })
    }

    rows = focusRows

    // Полоса вкладок: цифры 1–4 работают в любой раскладке; в подписи — счётчик вкладки
    const counts: Record<Tab, string> = {
      docs: String(t.docs.length),
      tasks: p ? `${p.done}/${p.total}` : t.commits.length ? `${t.commits.length} комм.` : '',
      rulings: String(t.rulings.length),
      deferred: String(deferred.length) + (openItems.length ? ` !${openItems.length}` : ''),
    }
    const titles: Record<Tab, string> = { docs: 'Документы', tasks: 'Задачи', rulings: 'Рулинги', deferred: 'Отложено' }
    const tabBar = (
      // Вкладки растянуты по ширине панели
      <Box key="tabs" width="100%" flexDirection="row" flexWrap="wrap" justifyContent="space-evenly" columnGap={2} marginTop={1}>
        {TABS.map((id, i) => (
          <Button
            key={'tab-' + id}
            label={`${tab === id ? '●' : '○'} ${titles[id]} ${counts[id]}`.trimEnd()}
            hotkey={String(i + 1)}
            plain
            dimColor={tab !== id}
            onPress={() => setTab(id)}
          />
        ))}
      </Box>
    )

    const extra: JSX.Element[] = []
    if (tab === 'tasks' && p) {
      const open = expandedFor(t.key, p)
      extra.push(
        <Button
          key="expand-all"
          label={open.size === p.tasks.length ? 'свернуть' : 'раскрыть'}
          hotkey="e"
          plain
          dimColor
          onPress={() => {
            if (open.size === p.tasks.length) open.clear()
            else for (const task of p.tasks) open.add(task.n)
            redraw()
          }}
        />,
        <Button
          key="toggle-done"
          label={hideDone ? 'показать ✓' : 'скрыть ✓'}
          hotkey="h"
          plain
          dimColor
          onPress={() => {
            hideDone = !hideDone
            redraw()
          }}
        />,
      )
    }

    return (
      <Box flexDirection="column">
        {head}
        {tabBar}
        <Text> </Text>
        {/* Содержимое вкладки — с отступом от краёв */}
        <Box flexDirection="column" paddingX={2}>
          {body}
        </Box>
        <Text> </Text>
        {/* Все клавиши — одной приглушённой строкой внизу */}
        <Box key="keys" flexDirection="row" flexWrap="wrap" columnGap={2}>
          <Text dimColor>{tab === 'docs' ? '↑↓ Enter: открыть' : '↑↓ Enter: раскрыть'}</Text>
          {branchButtons}
          {extra}
          {refreshButton}
        </Box>
      </Box>
    )
  })
}