@brimveyn/aimux 1.20.4 → 1.21.0

package/src/git/pr-status-poller.ts

@@ -0,0 +1,57 @@
+import { useEffect } from 'react'
+
+import { prStatusStore } from '../state/pr-status-store'
+import { collectPrStatus } from './pr-status'
+
+/** A run in flight is worth watching closely; a settled one barely changes. */
+const ACTIVE_INTERVAL_MS = 15_000
+const IDLE_INTERVAL_MS = 60_000
+const MAX_INTERVAL_MS = 120_000
+
+interface Options {
+  enabled: boolean
+  projectPath: string | undefined
+}
+
+/** One-shot refetch, for when an action we took just invalidated the state. */
+export async function refreshPrStatus(projectPath: string): Promise<void> {
+  prStatusStore.getState().setResult(await collectPrStatus(projectPath))
+}
+
+export function usePrStatusPolling({ enabled, projectPath }: Options): void {
+  useEffect(() => {
+    if (!enabled || !(projectPath != null && projectPath !== '')) return
+
+    prStatusStore.getState().reset()
+
+    let cancelled = false
+    let timer: ReturnType<typeof setTimeout> | null = null
+    let delay = ACTIVE_INTERVAL_MS
+
+    const schedule = () => {
+      if (cancelled) return
+      timer = setTimeout(() => void tick(), delay)
+    }
+
+    const tick = async () => {
+      const result = await collectPrStatus(projectPath)
+      if (cancelled) return
+      prStatusStore.getState().setResult(result)
+      if (result.kind === 'error') {
+        delay = Math.min(delay * 2, MAX_INTERVAL_MS)
+      } else if (result.kind === 'ok' && result.checks.some((c) => c.state === 'pending')) {
+        delay = ACTIVE_INTERVAL_MS
+      } else {
+        delay = IDLE_INTERVAL_MS
+      }
+      schedule()
+    }
+
+    void tick()
+
+    return () => {
+      cancelled = true
+      if (timer) clearTimeout(timer)
+    }
+  }, [enabled, projectPath])
+}

package/src/git/pr-status.ts

@@ -0,0 +1,227 @@
+import { runCli } from '../services/ai-usage/spawn'
+
+export type PrCheckState = 'pass' | 'fail' | 'pending' | 'skipping' | 'cancel'
+
+export interface PrCheck {
+  name: string
+  workflow: string
+  state: PrCheckState
+  url: string
+  durationMs: number | null
+}
+
+export interface PrSummary {
+  number: number
+  title: string
+  body: string
+  state: string
+  isDraft: boolean
+  base: string
+  head: string
+  reviewDecision: string
+  /** MERGEABLE | CONFLICTING | UNKNOWN */
+  mergeable: string
+  /** CLEAN | BLOCKED | BEHIND | UNSTABLE | DIRTY | DRAFT | HAS_HOOKS | UNKNOWN */
+  mergeStateStatus: string
+  additions: number
+  deletions: number
+  changedFiles: number
+  url: string
+}
+
+export type PrStatusResult =
+  | { kind: 'ok'; pr: PrSummary; checks: PrCheck[] }
+  | { kind: 'no-pr' }
+  | { kind: 'no-gh' }
+  | { kind: 'error'; message: string }
+
+const PR_VIEW_FIELDS = [
+  'number',
+  'title',
+  'body',
+  'state',
+  'isDraft',
+  'url',
+  'baseRefName',
+  'headRefName',
+  'reviewDecision',
+  'mergeable',
+  'mergeStateStatus',
+  'additions',
+  'deletions',
+  'changedFiles',
+  'statusCheckRollup',
+].join(',')
+
+const NOT_AN_ERROR = [
+  'no pull requests found',
+  'no git remotes',
+  'not a git repository',
+  'none of the git remotes',
+  'no default remote',
+]
+
+function str(value: unknown): string {
+  return typeof value === 'string' ? value : ''
+}
+
+function num(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) ? value : 0
+}
+
+function duration(startedAt: unknown, completedAt: unknown): number | null {
+  const start = Date.parse(str(startedAt))
+  const end = Date.parse(str(completedAt))
+  if (Number.isNaN(start) || Number.isNaN(end) || end < start) return null
+  return end - start
+}
+
+// `gh` documents these buckets for `pr checks --json bucket`; we derive the same
+// classification from the raw rollup so a single `pr view` call covers both the
+// summary and the checks.
+function checkRunState(status: string, conclusion: string): PrCheckState {
+  if (status !== 'COMPLETED') return 'pending'
+  if (conclusion === 'SUCCESS' || conclusion === 'NEUTRAL') return 'pass'
+  if (conclusion === 'SKIPPED') return 'skipping'
+  if (conclusion === 'CANCELLED') return 'cancel'
+  return 'fail'
+}
+
+function statusContextState(state: string): PrCheckState {
+  if (state === 'SUCCESS') return 'pass'
+  if (state === 'PENDING' || state === 'EXPECTED') return 'pending'
+  return 'fail'
+}
+
+function toCheck(raw: unknown): PrCheck | null {
+  if (typeof raw !== 'object' || raw === null) return null
+  const entry = raw as Record<string, unknown>
+  if (entry.__typename === 'StatusContext') {
+    const name = str(entry.context)
+    if (name === '') return null
+    return {
+      durationMs: null,
+      name,
+      state: statusContextState(str(entry.state)),
+      url: str(entry.targetUrl),
+      workflow: '',
+    }
+  }
+  const name = str(entry.name)
+  if (name === '') return null
+  return {
+    durationMs: duration(entry.startedAt, entry.completedAt),
+    name,
+    state: checkRunState(str(entry.status), str(entry.conclusion)),
+    url: str(entry.detailsUrl),
+    workflow: str(entry.workflowName),
+  }
+}
+
+export function parsePrView(raw: unknown): PrStatusResult {
+  if (typeof raw !== 'object' || raw === null) return { kind: 'no-pr' }
+  const pr = raw as Record<string, unknown>
+  if (typeof pr.number !== 'number') return { kind: 'no-pr' }
+  const rollup = Array.isArray(pr.statusCheckRollup) ? pr.statusCheckRollup : []
+  return {
+    checks: rollup.map(toCheck).filter((c): c is PrCheck => c !== null),
+    kind: 'ok',
+    pr: {
+      additions: num(pr.additions),
+      base: str(pr.baseRefName),
+      body: str(pr.body).trim(),
+      changedFiles: num(pr.changedFiles),
+      deletions: num(pr.deletions),
+      head: str(pr.headRefName),
+      isDraft: pr.isDraft === true,
+      mergeable: str(pr.mergeable),
+      mergeStateStatus: str(pr.mergeStateStatus),
+      number: pr.number,
+      reviewDecision: str(pr.reviewDecision),
+      state: str(pr.state),
+      title: str(pr.title),
+      url: str(pr.url),
+    },
+  }
+}
+
+export type PrAction = 'merge' | null
+
+export interface PrActionState {
+  label: string
+  action: PrAction
+  tone: 'ok' | 'blocked' | 'neutral'
+}
+
+/**
+ * The headline GitHub puts on the merge box, and the one action worth wiring to
+ * it. Order matters: a terminal state beats everything, then a hard blocker
+ * (conflicts, draft), then whatever the checks are doing. Anything we can't
+ * offer an action for still gets an honest label rather than a dead button.
+ */
+export function prActionState(pr: PrSummary, checks: PrCheck[]): PrActionState {
+  if (pr.state === 'MERGED') return { action: null, label: 'Merged', tone: 'neutral' }
+  if (pr.state === 'CLOSED') return { action: null, label: 'Closed', tone: 'blocked' }
+  if (pr.isDraft) return { action: null, label: 'Draft', tone: 'neutral' }
+  if (pr.mergeable === 'CONFLICTING') {
+    return { action: null, label: 'Merge conflicts', tone: 'blocked' }
+  }
+  if (checks.some((c) => c.state === 'pending')) {
+    return { action: null, label: 'Checks running', tone: 'neutral' }
+  }
+  if (pr.mergeStateStatus === 'BLOCKED') return { action: null, label: 'Blocked', tone: 'blocked' }
+  if (pr.mergeStateStatus === 'BEHIND')
+    return { action: null, label: 'Out of date', tone: 'blocked' }
+  // UNSTABLE means a non-required check failed; GitHub still lets you merge.
+  if (pr.mergeStateStatus === 'UNSTABLE') {
+    return { action: 'merge', label: 'Checks failing', tone: 'blocked' }
+  }
+  if (pr.mergeStateStatus === 'CLEAN') {
+    return { action: 'merge', label: 'Ready to merge', tone: 'ok' }
+  }
+  return { action: null, label: 'Checking…', tone: 'neutral' }
+}
+
+export interface ClampedBody {
+  text: string
+  truncated: boolean
+}
+
+/**
+ * A PR body is a whole document; a bar widget gets a preview of it. Clamping on
+ * lines alone breaks on a wall-of-text paragraph and clamping on characters
+ * alone breaks on a bullet list, so whichever limit bites first wins.
+ */
+export function clampPrBody(body: string, maxLines = 5, maxChars = 260): ClampedBody {
+  const full = body.trimEnd()
+  const lines = full.split('\n')
+  let text = lines.slice(0, maxLines).join('\n')
+  if (text.length > maxChars) {
+    const space = text.lastIndexOf(' ', maxChars)
+    // Only respect a word boundary that isn't absurdly early, else hard-cut.
+    text = text.slice(0, space > maxChars / 2 ? space : maxChars)
+  }
+  text = text.trimEnd()
+  return { text, truncated: text.length < full.length }
+}
+
+export async function collectPrStatus(cwd: string): Promise<PrStatusResult> {
+  const gh = Bun.which('gh')
+  if (gh === null) return { kind: 'no-gh' }
+
+  const result = await runCli(gh, ['pr', 'view', '--json', PR_VIEW_FIELDS], 15_000, cwd)
+  if (!result.ok) {
+    // `gh` exits non-zero for every "there is simply nothing to show" case too:
+    // no PR on the branch, no GitHub remote, or a directory that isn't a repo
+    // at all (aimux sessions can point anywhere). None of those is an error.
+    const stderr = result.stderr.toLowerCase()
+    if (NOT_AN_ERROR.some((needle) => stderr.includes(needle))) return { kind: 'no-pr' }
+    return { kind: 'error', message: (result.error ?? 'gh failed').slice(0, 200) }
+  }
+
+  try {
+    return parsePrView(JSON.parse(result.stdout))
+  } catch {
+    return { kind: 'no-pr' }
+  }
+}

package/src/index.tsx

@@ -72,8 +72,14 @@ if (command === '--help' || command === '-h' || command === 'help') {
   process.exit(await runCli([]))
 }
 
+// Sequential ON PURPOSE: @opentui/react evaluates @opentui/core as part of its
+// own module graph. Loading both concurrently races the two evaluations and
+// react's chunk can hit `class X extends TextNodeRenderable` while core is
+// still initializing (ReferenceError: cannot access before initialization).
+// react has to wait on core either way, so this costs nothing.
+const { createCliRenderer } = await import('@opentui/core')
+
 const [
-  { createCliRenderer },
   { createRoot },
   { App },
   { loadUserConfig },
@@ -82,7 +88,6 @@ const [
   { createSessionBackend },
   { maybeAutoInstallCompletion },
 ] = await Promise.all([
-  import('@opentui/core'),
   import('@opentui/react'),
   import('./app'),
   import('./config/loader'),

package/src/platform/open-url.ts

@@ -0,0 +1,39 @@
+import { logDebug } from '../debug/input-log'
+import { toast } from '../state/toast-store'
+import { detectClipboardPlatform } from './clipboard'
+
+/**
+ * URLs here come from the GitHub API, i.e. outside the process. Handing an
+ * arbitrary scheme to the OS opener is a code-execution path (`file://`,
+ * `javascript:`, custom app handlers), so only plain https is allowed through.
+ */
+function isSafeUrl(url: string): boolean {
+  return /^https:\/\/[^\s]+$/.test(url)
+}
+
+export function openUrlCommand(platform: string, isWsl: boolean, url: string): string[] | null {
+  if (!isSafeUrl(url)) return null
+  if (platform === 'darwin') return ['open', url]
+  // Under WSL the browser lives on the Windows side; explorer.exe is the one
+  // bridge present on every install (wslview/xdg-open often are not).
+  if (platform === 'win32' || isWsl) return ['explorer.exe', url]
+  return ['xdg-open', url]
+}
+
+export function openUrl(url: string): void {
+  const { isWsl, platform } = detectClipboardPlatform()
+  const argv = openUrlCommand(platform, isWsl, url)
+  if (!argv) {
+    logDebug('platform.openUrl.rejected', { url })
+    return
+  }
+  try {
+    Bun.spawn(argv, { stderr: 'ignore', stdin: 'ignore', stdout: 'ignore' })
+  } catch (error) {
+    logDebug('platform.openUrl.error', {
+      argv,
+      error: error instanceof Error ? error.message : String(error),
+    })
+    toast.error(`Could not open ${argv[0]}`)
+  }
+}

package/src/services/ai-usage/spawn.ts

@@ -10,9 +10,11 @@ const DEFAULT_TIMEOUT_MS = 15_000
 export async function runCli(
   command: string,
   args: string[],
-  timeoutMs: number = DEFAULT_TIMEOUT_MS
+  timeoutMs: number = DEFAULT_TIMEOUT_MS,
+  cwd?: string
 ): Promise<CliResult> {
   const proc = Bun.spawn([command, ...args], {
+    cwd,
     stderr: 'pipe',
     stdin: 'ignore',
     stdout: 'pipe',

package/src/state/bars.ts

@@ -0,0 +1,75 @@
+import type { BarSide, BarsState, BarState, BarWidget } from './types'
+
+export const BAR_MIN_WIDTH = 18
+export const BAR_MAX_WIDTH = 80
+
+/** Widget ids the app knows how to render. Unknown ids are pruned on load. */
+export const KNOWN_WIDGET_IDS = ['workspaces', 'git'] as const
+
+/** Smallest share of a bar a single widget may shrink to, as a fraction. */
+const MIN_WIDGET_SHARE = 0.1
+
+export function clampBarWidth(width: number): number {
+  return Math.min(BAR_MAX_WIDTH, Math.max(BAR_MIN_WIDTH, Math.round(width)))
+}
+
+export function visibleWidgets(bar: BarState): BarWidget[] {
+  return bar.widgets.filter((widget) => widget.visible)
+}
+
+/**
+ * The single authority on how many columns a bar occupies. Both the `Bar`
+ * component and the terminal-size computation must call this — a mismatch
+ * silently corrupts PTY columns and mouse hit-testing.
+ */
+export function getBarWidth(bar: BarState): number {
+  if (!bar.visible || visibleWidgets(bar).length === 0) return 0
+  return clampBarWidth(bar.width)
+}
+
+export function findWidgetBar(bars: BarsState, widgetId: string): BarSide | null {
+  if (bars.left.widgets.some((widget) => widget.id === widgetId)) return 'left'
+  if (bars.right.widgets.some((widget) => widget.id === widgetId)) return 'right'
+  return null
+}
+
+function totalGrow(widgets: BarWidget[]): number {
+  return widgets.reduce((sum, widget) => sum + widget.grow, 0)
+}
+
+/**
+ * Move the boundary between visible widgets `index` and `index + 1` by
+ * `deltaGrow`. Only the pair changes, so the bar's total grow is preserved and
+ * no renormalisation is ever needed — including when a widget is added.
+ */
+export function shiftBoundary(bar: BarState, index: number, deltaGrow: number): BarWidget[] {
+  const visible = visibleWidgets(bar)
+  const above = visible[index]
+  const below = visible[index + 1]
+  if (!above || !below) return bar.widgets
+
+  const min = Math.max(1, Math.round(totalGrow(visible) * MIN_WIDGET_SHARE))
+  const pair = above.grow + below.grow
+  if (pair < min * 2) return bar.widgets
+
+  const nextAbove = Math.min(pair - min, Math.max(min, Math.round(above.grow + deltaGrow)))
+  if (nextAbove === above.grow) return bar.widgets
+
+  return bar.widgets.map((widget) => {
+    if (widget.id === above.id) return { ...widget, grow: nextAbove }
+    if (widget.id === below.id) return { ...widget, grow: pair - nextAbove }
+    return widget
+  })
+}
+
+/**
+ * Convert an absolute drag position (a 0..1 fraction of the bar's body) into
+ * the grow delta `shiftBoundary` expects for that boundary.
+ */
+export function boundaryDeltaFromRatio(bar: BarState, index: number, ratio: number): number {
+  const visible = visibleWidgets(bar)
+  const target = visible[index]
+  if (!target) return 0
+  const above = visible.slice(0, index).reduce((sum, widget) => sum + widget.grow, 0)
+  return ratio * totalGrow(visible) - above - target.grow
+}

package/src/state/git-pane-sizing.ts

@@ -1,15 +1,6 @@
 export const GIT_PANE_MIN_RATIO = 0.2
 export const GIT_PANE_MAX_RATIO = 0.8
-export const GIT_PANE_MIN_WIDTH = 20
-export const GIT_PANE_MAX_WIDTH = 80
 
 export function clampGitPaneRatio(value: number): number {
   return Math.max(GIT_PANE_MIN_RATIO, Math.min(GIT_PANE_MAX_RATIO, value))
 }
-
-export function getGitPaneWidthFromRatio(ratio: number): number {
-  return Math.max(
-    GIT_PANE_MIN_WIDTH,
-    Math.min(GIT_PANE_MAX_WIDTH, Math.round(clampGitPaneRatio(ratio) * GIT_PANE_MAX_WIDTH))
-  )
-}

package/src/state/pr-status-store.ts

@@ -0,0 +1,39 @@
+import { useStore } from 'zustand'
+import { createStore } from 'zustand/vanilla'
+
+import type { PrStatusResult } from '../git/pr-status'
+
+export interface PrStatusState {
+  result: PrStatusResult | null
+  /** True once a fetch failed but we are still showing the previous good result. */
+  stale: boolean
+  setResult: (result: PrStatusResult) => void
+  reset: () => void
+}
+
+export const prStatusStore = createStore<PrStatusState>((set) => ({
+  reset: () => set({ result: null, stale: false }),
+  result: null,
+  setResult: (result: PrStatusResult) =>
+    set((state) => {
+      // A transient `gh` failure shouldn't blank a PR we already resolved — keep
+      // the last good snapshot and mark it stale instead (same contract as
+      // ai-usage-store's setSnapshot).
+      if (result.kind === 'error' && state.result?.kind === 'ok') return { stale: true }
+      return { result, stale: false }
+    }),
+  stale: false,
+}))
+
+/**
+ * The PR state row occupies its band both while the first fetch is in flight
+ * and once it resolved to a PR — anything else (no PR, no gh, error) gives the
+ * row back. Shared so the header and the row itself can never disagree and
+ * shift the layout under the user.
+ */
+export const selectPrRowVisible = (state: PrStatusState): boolean =>
+  state.result === null || state.result.kind === 'ok'
+
+export function usePrStatusStore<T>(selector: (state: PrStatusState) => T): T {
+  return useStore(prStatusStore, selector)
+}

package/src/state/reducers/git-panel-state.ts

@@ -105,58 +105,11 @@ function sameFiles(a: GitFileEntry[], b: GitFileEntry[]): boolean {
 
 export function reduceGitPanelState(state: AppState, action: AppAction): AppState | null {
   switch (action.type) {
-    case 'toggle-git-pane': {
-      const nextVisible = !state.gitPane.visible
-      const sidebarMustShow = state.gitPane.mode === 'embedded' && nextVisible
-      return {
-        ...state,
-        gitPane: { ...state.gitPane, visible: nextVisible },
-        sidebar: sidebarMustShow ? { ...state.sidebar, visible: true } : state.sidebar,
-      }
-    }
-    case 'resize-git-pane': {
-      const target = state.gitPane.mode === 'pane' ? 'paneRatio' : 'embeddedRatio'
-      const nextRatio = clampRatio(state.gitPane[target] + action.delta)
-      if (nextRatio === state.gitPane[target]) return state
-      return { ...state, gitPane: { ...state.gitPane, [target]: nextRatio } }
-    }
-    case 'set-git-pane-ratio': {
-      const key = action.target === 'pane' ? 'paneRatio' : 'embeddedRatio'
-      const nextRatio = clampRatio(action.ratio)
-      if (nextRatio === state.gitPane[key]) return state
-      return { ...state, gitPane: { ...state.gitPane, [key]: nextRatio } }
-    }
     case 'resize-git-diff-pane': {
       const nextRatio = clampRatio(state.gitPane.diffModeRatio + action.delta)
       if (nextRatio === state.gitPane.diffModeRatio) return state
       return { ...state, gitPane: { ...state.gitPane, diffModeRatio: nextRatio } }
     }
-    case 'set-git-pane-mode': {
-      if (state.gitPane.mode === action.mode) return state
-      const isEmbedded = action.mode === 'embedded'
-      const isValidEmbedded =
-        state.gitPane.position === 'top' || state.gitPane.position === 'bottom'
-      const isValidPane = state.gitPane.position === 'left' || state.gitPane.position === 'right'
-      let nextPosition: typeof state.gitPane.position
-      if (isEmbedded) {
-        nextPosition = isValidEmbedded ? state.gitPane.position : 'bottom'
-      } else {
-        nextPosition = isValidPane ? state.gitPane.position : 'left'
-      }
-      return {
-        ...state,
-        gitPane: { ...state.gitPane, mode: action.mode, position: nextPosition },
-      }
-    }
-    case 'set-git-pane-position': {
-      const validForMode =
-        state.gitPane.mode === 'embedded'
-          ? action.position === 'top' || action.position === 'bottom'
-          : action.position === 'left' || action.position === 'right'
-      if (!validForMode) return state
-      if (state.gitPane.position === action.position) return state
-      return { ...state, gitPane: { ...state.gitPane, position: action.position } }
-    }
     case 'git-refresh-success': {
       const prev = state.gitPanel
       const next = action.payload

package/src/state/reducers/ui-state.ts

@@ -1,21 +1,91 @@
-import type { AppAction, AppState } from '../types'
+import type { AppAction, AppState, BarSide, BarState, BarWidget } from '../types'
+
+import {
+  boundaryDeltaFromRatio,
+  clampBarWidth,
+  findWidgetBar,
+  shiftBoundary,
+  visibleWidgets,
+} from '../bars'
+
+function withBar(state: AppState, side: BarSide, next: BarState): AppState {
+  if (next === state.bars[side]) return state
+  return { ...state, bars: { ...state.bars, [side]: next } }
+}
+
+function setBarWidth(state: AppState, side: BarSide, width: number): AppState {
+  const bar = state.bars[side]
+  const next = clampBarWidth(width)
+  if (next === bar.width) return state
+  return withBar(state, side, { ...bar, width: next })
+}
+
+/**
+ * Move `widgetId` to `side` at `index`. Covers both cross-bar moves and
+ * in-bar reordering — removing then re-inserting is the same operation.
+ */
+function moveWidget(state: AppState, widgetId: string, side: BarSide, index: number): AppState {
+  const from = findWidgetBar(state.bars, widgetId)
+  if (from === null) return state
+  const widget = state.bars[from].widgets.find((w) => w.id === widgetId)
+  if (!widget) return state
+
+  const source = state.bars[from].widgets.filter((w) => w.id !== widgetId)
+  const target: BarWidget[] = from === side ? source : [...state.bars[side].widgets]
+  const at = Math.max(0, Math.min(target.length, index))
+  target.splice(at, 0, widget)
+
+  const bars = { ...state.bars }
+  bars[from] = { ...state.bars[from], widgets: from === side ? target : source }
+  // Showing a widget in a hidden bar would silently swallow it.
+  bars[side] = { ...bars[side], visible: bars[side].visible || widget.visible, widgets: target }
+  return { ...state, bars }
+}
 
 export function reduceUIState(state: AppState, action: AppAction): AppState | null {
   switch (action.type) {
-    case 'toggle-sidebar':
-      return { ...state, sidebar: { ...state.sidebar, visible: !state.sidebar.visible } }
-    case 'resize-sidebar': {
-      const width = Math.min(
-        state.sidebar.maxWidth,
-        Math.max(state.sidebar.minWidth, state.sidebar.width + action.delta)
+    case 'toggle-bar': {
+      const bar = state.bars[action.side]
+      return withBar(state, action.side, { ...bar, visible: !bar.visible })
+    }
+    case 'resize-bar':
+      return setBarWidth(state, action.side, state.bars[action.side].width + action.delta)
+    case 'set-bar-width':
+      return setBarWidth(state, action.side, action.width)
+    case 'toggle-widget': {
+      const side = findWidgetBar(state.bars, action.widgetId)
+      if (side === null) return state
+      const bar = state.bars[side]
+      const widgets = bar.widgets.map((w) =>
+        w.id === action.widgetId ? { ...w, visible: !w.visible } : w
       )
-      if (width === state.sidebar.width) return state
-      return { ...state, sidebar: { ...state.sidebar, width } }
+      const revealed = widgets.some((w) => w.id === action.widgetId && w.visible)
+      return withBar(state, side, { ...bar, visible: bar.visible || revealed, widgets })
+    }
+    case 'move-widget':
+      return moveWidget(state, action.widgetId, action.side, action.index)
+    case 'set-bar-boundary': {
+      const bar = state.bars[action.side]
+      const delta = boundaryDeltaFromRatio(bar, action.index, action.ratio)
+      const widgets = shiftBoundary(bar, action.index, delta)
+      if (widgets === bar.widgets) return state
+      return withBar(state, action.side, { ...bar, widgets })
     }
-    case 'set-sidebar-width': {
-      const width = Math.min(state.sidebar.maxWidth, Math.max(state.sidebar.minWidth, action.width))
-      if (width === state.sidebar.width) return state
-      return { ...state, sidebar: { ...state.sidebar, width } }
+    case 'resize-widget': {
+      // Keyboard resize: grow/shrink this widget against its neighbour. The
+      // widget below owns the boundary above it, so the sign flips there.
+      const side = findWidgetBar(state.bars, action.widgetId)
+      if (side === null) return state
+      const bar = state.bars[side]
+      const visible = visibleWidgets(bar)
+      const at = visible.findIndex((w) => w.id === action.widgetId)
+      if (at === -1) return state
+      const total = visible.reduce((sum, w) => sum + w.grow, 0)
+      const index = at > 0 ? at - 1 : at
+      const deltaGrow = action.delta * total * (at > 0 ? -1 : 1)
+      const widgets = shiftBoundary(bar, index, deltaGrow)
+      if (widgets === bar.widgets) return state
+      return withBar(state, side, { ...bar, widgets })
     }
     case 'set-focus-mode':
       return { ...state, focusMode: action.focusMode }