reslop 0.1.7 → 0.1.9

package/lib/session.js

@@ -1,2448 +1,707 @@
 'use strict';
 
-const fs = require('node:fs');
-const path = require('node:path');
-
 const render = require('./render.js');
 const keys = require('./keys.js');
 const review = require('./review.js');
-const wrap = require('./wrap.js');
-const { extractText, isRange } = require('./select.js');
 const { copyText } = require('./clipboard.js');
-const { watchResize } = require('./sys.js');
 const files = require('./files.js');
-const { fileEntries, itemPath, TODO_FILE } = files;
-const { isTodoItem, isTodosEntry, REPO_TODOS_LABEL, makeTodoItem } = files;
-const { Editor } = require('./editor.js');
-const { refreshIndexPatches, blockAddText } = require('./diff.js');
-const update = require('./update.js');
-const { checkUpdate, installUpdate, markSkipped } = update;
-
-const { renderFrame, presentRows, presentCursor } = render;
-const { noteInnerWidth, codeInnerWidth } = render;
-const { actionFromKey, hitAction, decodeChunk } = keys;
-const { disabledActions } = keys;
-const { cursorInWrap, wrapDoc } = wrap;
-const { AUTOSAVE_MS, listReviewNames, loadTemplates } = review;
-const { resolveReviewPath, loadReview, createStore } = review;
-const { noteCounts, hasNotes, setFeedback, setCode, addTodo } = review;
-const { applyImportedNotes } = review;
-const { setTodoText, removeTodo, flushReview } = review;
-const { feedbackKey, checkLabel, rankedTemplates } = review;
-const { prefixTemplates, TEMPLATE_SHOW, rememberTemplate } = review;
+const { makeTodoItem } = files;
+const { renderFrame } = render;
+const { decodeChunk } = keys;
+const { AUTOSAVE_MS, hasNotes } = review;
+const capabilities = require('./capabilities.js');
+const { sessionCapabilities, createReviewStorage } = capabilities;
+const { createTerminal, LEAVE_TERM } = require('./session/terminal.js');
+const { createLoadCoordinator } = require('./session/load.js');
+const items = require('./session/items.js');
+const { createItemCollection } = items;
+const { createNavigation } = require('./session/navigation.js');
+const { createReviewController } = require('./session/review.js');
+const { createUpdateCoordinator } = require('./session/update.js');
+const { createProgress } = require('./session/progress.js');
+const { createComposer } = require('./session/compose.js');
+const { createOpsRunner } = require('./session/ops.js');
+const { createChangeActions } = require('./session/change-actions.js');
+const { createCommitController } = require('./session/commit.js');
+const { createBranchController } = require('./session/branches.js');
+const accessors = require('./session/accessors.js');
+const { bindAccessors, bindGetters, bindAlias } = accessors;
+const { createView } = require('./session/view.js');
+const { createFilesPane } = require('./session/files-pane.js');
+const { createLifecycle } = require('./session/lifecycle.js');
+const { createPointer } = require('./session/pointer.js');
+const { createDispatcher, createInput } = require('./session/dispatch.js');
 
-const LAYOUTS = ['unified', 'mixed', 'side'];
-const READ_ONLY_ORIGINS = ['commit', 'pr'];
-const SOURCE_KIND = {
-  'github-pr': 'pr',
-  'gitlab-mr': 'mr',
-};
-const ENTER_TERM = '\x1b[?1049h\x1b[?25l\x1b[?7l\x1b[?1002h\x1b[?1006h';
-const LEAVE_TERM =
-  '\x1b[?1006l\x1b[?1002l\x1b[?7h\x1b[0 q\x1b[?12l\x1b[?25h\x1b[?1049l';
 const CURSOR_BLINK_MS = 500;
 const PROGRESS_MS = 80;
 
 const systemNow = () => new Date();
 
-const isReadOnlyOrigin = (origin) => READ_ONLY_ORIGINS.includes(origin);
-
-const relabelStatus = (entries, from, to) => {
-  if (!to) return entries;
-  return entries.map((entry) => {
-    if (entry.status !== from) return entry;
-    return { ...entry, status: to };
-  });
-};
-
-const depChangeKey = (item) => {
-  const change = item.dep && item.dep.change;
-  if (!change) return '';
-  return `${change.section}/${change.name}`;
-};
-
-const needsReload = (item) => item.reload === true;
-
-const npmBusyKind = (item) => {
-  const change = item && item.dep && item.dep.change;
-  if (!change || !change.propose) return '';
-  if (change.unused) return 'npm uninstall';
-  if (change.section === 'resolved') return 'npm audit fix';
-  return 'npm i';
-};
-
-const itemKey = (item) => {
-  if (!item || !item.file) return '';
-  const rel = itemPath(item);
-  if (isTodoItem(item)) return `todo:${TODO_FILE}`;
-  const origin = item.origin ?? '';
-  const depId = depChangeKey(item);
-  if (depId) return `${origin}:${rel}:dep:${depId}`;
-  if (!item.hunk) {
-    const block = item.blockId ?? '-';
-    return `${origin}:${rel}:file:${block}`;
-  }
-  const oldStart = item.hunk.oldStart;
-  const newStart = item.hunk.newStart;
-  const block = item.blockId ?? '-';
-  return `${origin}:${rel}:${oldStart}:${newStart}:${block}`;
-};
-
-const itemFeedKey = (item) => {
-  if (!item || !item.file || isTodoItem(item)) return '';
-  const hunk = item.hunk;
-  const depId = depChangeKey(item);
-  const file = depId ? `${itemPath(item)}#${depId}` : itemPath(item);
-  const oldStart = hunk ? hunk.oldStart : 0;
-  const newStart = hunk ? hunk.newStart : 0;
-  const blockId = item.blockId ?? 0;
-  return feedbackKey({ file, oldStart, newStart, blockId });
-};
-
-const canEditCode = (item) => {
-  if (!item || isTodoItem(item)) return false;
-  if (!item.hunk || !item.file) return false;
-  if (item.file.isBinary) return false;
-  return true;
-};
-
-const isAbortError = (error) => !!(error && error.code === 'ABORT');
-
-const sameCursor = (a, b) => {
-  if (!a && !b) return true;
-  if (!a || !b) return false;
-  return a.x === b.x && a.y === b.y;
-};
-
-const QUIT_CONFIRM = {
-  f: (session) => session.finishQuit('ready'),
-  c: (session) => session.finishQuit('editing'),
-  'ctrl-c': (session) => session.finishQuit('ready'),
-  escape: (session) => session.cancelQuit(),
-};
-
-const COMMIT_CONFIRM = {
-  c: (session) => session.startGitCommit('commit'),
-  a: (session) => session.startGitCommit('amend'),
-  f: (session) => session.startGitCommit('fixup'),
-  escape: (session) => session.cancelCommit(),
-};
-
-const UPDATE_CONFIRM = {
-  y: (session) => session.acceptUpdate(),
-  n: (session) => session.declineUpdate(),
-  escape: (session) => session.declineUpdate(),
-};
-
-const DROP_CONFIRM = {
-  y: (session) => session.confirmDropBranch(),
-  n: (session) => session.cancelDropBranch(),
-  escape: (session) => session.cancelDropBranch(),
-};
-
-const PUSH_CONFIRM = {
-  f: (session) => session.onForcePush(),
-  escape: (session) => session.cancelPush(),
-};
-
-const CONFIRM_MODE = [
-  'confirmQuit',
-  'confirmCommit',
-  'confirmUpdate',
-  'confirmDrop',
-  'confirmPush',
-];
-
-const COMMIT_STATUS = {
-  commit: 'committed',
-  amend: 'amended',
-  fixup: 'fixup',
-};
-
-const COMPOSE_EDITS = ['backspace', 'delete', 'ctrl-z', 'ctrl-y'];
-
-const COMPOSE_SPECIAL = {
-  backspace: (session) => session.editor.backspace(),
-  delete: (session) => session.editor.delete(),
-  left: (session) => session.editor.move(-1),
-  right: (session) => session.editor.move(1),
-  up: (session) => session.moveComposeLine(-1),
-  down: (session) => session.moveComposeLine(1),
-  home: (session) => session.editor.home(),
-  end: (session) => session.editor.end(),
-  'ctrl-a': (session) => session.editor.home(),
-  'ctrl-e': (session) => session.editor.end(),
-  'ctrl-z': (session) => session.editor.undoEdit(),
-  'ctrl-y': (session) => session.editor.redoEdit(),
-  tab: (session) => session.composeTab(),
-};
-
-const HANDLERS = {
-  add: (session) => session.onAdd(),
-  unstage: (session) => session.onUnstage(),
-  revert: (session) => session.onRevert(),
-  next: (session) => session.onNext(),
-  prev: (session) => session.onPrev(),
-  layout: (session) => session.onLayout(),
-  files: (session) => session.onFiles(),
-  feedback: (session) => session.onFeedback(),
-  todo: (session) => session.onTodo(),
-  code: (session) => session.onCode(),
-  reload: (session) => session.onReload(),
-  commit: (session) => session.onCommit(),
-  branch: (session) => session.onBranch(),
-  pull: (session) => session.onPull(),
-  push: (session) => session.onPush(),
-  newBranch: (session) => session.onNewBranch(),
-  rebase: (session) => session.onRebaseBranch(),
-  drop: (session) => session.onDropBranch(),
-  open: (session) => session.onOpenFile(),
-  removeTodo: (session) => session.removeFocusedTodo(),
-  quit: (session) => session.onQuit(),
-  scrollUp: (session) => session.onScroll(-1),
-  scrollDown: (session) => session.onScroll(1),
-  pageUp: (session) => session.onScroll(session.scrollStep(-1)),
-  pageDown: (session) => session.onScroll(session.scrollStep(1)),
-  halfUp: (session) => session.onScroll(session.scrollStep(-0.5)),
-  halfDown: (session) => session.onScroll(session.scrollStep(0.5)),
-};
-
-const KEY_MODE = {
-  confirmQuit: (session, key) => session.onConfirmQuit(key),
-  confirmCommit: (session, key) => session.onConfirmCommit(key),
-  confirmUpdate: (session, key) => session.onConfirmUpdate(key),
-  confirmDrop: (session, key) => session.onConfirmDrop(key),
-  confirmPush: (session, key) => session.onConfirmPush(key),
-  compose: (session, key) => session.handleComposeKey(key),
-};
-
-const COMPOSE_LEAVE = ['next', 'prev', 'todo'];
-const TODO_TYPE_SKIP = [
-  'enter',
-  'escape',
-  'tab',
-  'backspace',
-  'delete',
-  'left',
-  'right',
-  'up',
-  'down',
-  'home',
-  'end',
-  'j',
-  'k',
-  'n',
-  'p',
-  'q',
-];
-
-const isTodoTypeKey = (key) => {
-  if (!key) return false;
-  if (TODO_TYPE_SKIP.includes(key)) return false;
-  if (key.startsWith('ctrl-')) return false;
-  if (key.startsWith('alt-')) return false;
-  return key.charCodeAt(0) >= 32;
-};
-
-const MOUSE_KIND = {
-  wheelUp: (session) => session.onScroll(-1),
-  wheelDown: (session) => session.onScroll(1),
-  press: (session, event) => session.onMousePress(event),
-  drag: (session, event) => session.onMouseDrag(event),
-  release: (session, event) => session.onMouseRelease(event),
+const targetHasStaged = (session) => {
+  if (session.repo.hasStaged) return session.repo.hasStaged(session.top);
+  return session.items.some((item) => item.origin === 'staged');
 };
 
-const RELEASE_HITS = [
-  {
-    match: () => true,
-    hits: (frame) => frame?.statusHits,
-    onHit: (session) => session.onBranch(),
-  },
-  {
-    match: (session) => session.pane === 'files',
-    hits: (frame) => frame?.fileHits,
-    onHit: (session, hit) => {
-      session.fileCursor = hit.cursor;
-      session.onOpenFile();
-    },
-  },
-  {
-    match: (session) => session.pane === 'branches',
-    hits: (frame) => frame?.fileHits,
-    onHit: (session, hit) => {
-      session.branchCursor = hit.cursor;
-      session.onCheckoutBranch();
-    },
-  },
-  {
-    match: (session) => session.pane === 'diff',
-    hits: (frame) => frame?.todoHits,
-    onHit: (session, hit) => session.onTodoHit(hit.cursor),
-  },
-  {
-    match: (session) => session.mode === 'compose',
-    hits: (frame) => frame?.templateHits,
-    onHit: (session, hit) => session.selectTemplate(hit.cursor),
-  },
-];
-
-class Session {
-  assignOptions(options) {
-    this.repo = options.repo;
-    this.cwd = options.cwd;
-    this.paths = options.paths ?? [];
-    this.stdin = options.stdin ?? null;
-    this.stdout = options.stdout;
-    this.color = options.color ?? true;
-    this.copyText = options.copyText ?? copyText;
-    const termSize = () => {
-      const width = this.stdout.columns ?? 80;
-      const height = this.stdout.rows ?? 24;
-      return { width, height };
-    };
-    this.getSize = options.getSize ?? termSize;
-    this.pane = options.startPane ?? 'files';
-    this.rev = options.rev ?? null;
-    this.revShort = '';
-    this.sourceLabel = options.sourceLabel ?? '';
-    this.repoName = options.repoName ?? '';
-    this.change = options.change ?? null;
-    this.readdirSync = options.readdirSync ?? fs.readdirSync;
-    this.readFileSync = options.readFileSync ?? fs.readFileSync;
-    this.writeFileSync = options.writeFileSync ?? fs.writeFileSync;
-    this.mkdirSync = options.mkdirSync ?? fs.mkdirSync;
-    this.now = options.now ?? systemNow;
-    this.forceNewReview = options.newReview === true;
-    this.readOnly = options.readOnly === true;
-    this.audit = options.audit === true;
-    this.outdatedMap = options.outdatedMap;
-    this.auditMap = options.auditMap;
-    this.setInterval = options.setInterval ?? setInterval;
-    this.clearInterval = options.clearInterval ?? clearInterval;
-    this.updateOpts = options.update;
-  }
-
-  resetState() {
-    this.items = [];
-    this.dismissed = new Set();
-    this.top = this.cwd;
-    this.index = 0;
-    this.fileCursor = 0;
-    this.reviewPath = null;
-    this.branch = '';
-    this.branches = [];
-    this.branchCursor = 0;
-    this.dropName = '';
-    this.scroll = 0;
-    this.status = '';
-    this.layout = 'unified';
-    this.done = false;
-    this.exitCode = 0;
-    this.carry = '';
-    this.lastFrame = null;
-    this.lastPresentedCursor = null;
-    this.lastSize = null;
-    this.selection = null;
-    this.mouseAnchor = null;
-    this.pendingClick = null;
-    this.abortController = null;
-    this.notes = null;
-    this.didResumeReview = false;
-    this.importedRemoteNotes = false;
-    this.mode = 'review';
-    this.editor = null;
-    this.composeKind = null;
-    this.commitKind = null;
-    this.composeTodoId = null;
-    this.composeBaseline = '';
-    this.todoFocus = 0;
-    this.todoOpen = false;
-    this.todoItem = makeTodoItem();
-    this.templateIndex = -1;
-    this.templateFocus = false;
-    this.saveTimer = null;
-    this.blinkTimer = null;
-    this.blinkOn = true;
-    this.progressTimer = null;
-    this.progressFrame = 0;
-    this.gitBusy = false;
-    this.loadGen = 0;
-    this.loadAbort = null;
-    this.loadPromise = null;
-    this.busy = '';
-    this.emptyReview = false;
-    this.loadError = null;
-    this.didLoad = false;
-    this.pendingExtras = false;
-    this.uiOpen = false;
-    this.finishReadLoop = null;
-    this.updateOffer = false;
-    this.updateFrom = '';
-    this.updateTo = '';
-    this.updatePromise = null;
-    this.installPromise = null;
-  }
-
-  constructor(options) {
-    this.assignOptions(options);
-    this.resetState();
-  }
-
-  loadOptions(extra = {}) {
-    const commit = this.rev;
-    const audit = this.audit;
-    const outdatedMap = this.outdatedMap;
-    const auditMap = this.auditMap;
-    return { commit, audit, outdatedMap, auditMap, ...extra };
-  }
-
-  shouldDeferExtras() {
-    if (!this.audit) return false;
-    if (this.outdatedMap !== undefined && this.auditMap !== undefined) {
-      return false;
-    }
-    return true;
-  }
-
-  bumpLoad() {
-    this.loadGen += 1;
-    if (this.loadAbort) this.loadAbort.abort();
-    this.loadAbort = new AbortController();
-  }
-
-  ensureRepo() {
-    if (!this.repo.toplevel) return;
-    this.top = this.repo.toplevel(this.cwd);
-  }
-
-  applyLoaded(loaded) {
-    const wasTodo = this.todoOpen === true;
-    const here = itemKey(this.current());
-    this.top = loaded.top ?? this.cwd;
-    const items = loaded.items;
-    this.items = items.filter((item) => !this.dismissed.has(itemKey(item)));
-    if (loaded.rev) {
-      this.rev = loaded.rev;
-    }
-    if (loaded.revShort) {
-      this.revShort = loaded.revShort;
-    } else if (this.rev && !this.revShort) {
-      this.revShort = this.rev.slice(0, 7);
-    }
-    if (loaded.sourceLabel) this.sourceLabel = loaded.sourceLabel;
-    if (loaded.change) this.change = loaded.change;
-    if (loaded.branch !== undefined) this.branch = loaded.branch || '';
-    const repository = this.change ? this.change.repository : '';
-    if (!this.repoName && repository) this.repoName = repository;
-    if (!this.notes) this.initReview();
-    const imported = loaded.imported;
-    if (imported && !this.didResumeReview && !this.importedRemoteNotes) {
-      applyImportedNotes(this.notes, imported);
-      this.importedRemoteNotes = true;
-    }
-    this.todoOpen = wasTodo;
-    if (here && !wasTodo) {
-      const idx = this.items.findIndex((item) => itemKey(item) === here);
-      if (idx >= 0) this.index = idx;
-    }
-    this.clampIndex();
-    this.syncReviewPath();
-    this.syncFileCursor();
-    this.didLoad = true;
-    this.pendingExtras = loaded.pending === true;
-  }
-
-  load() {
-    const loaded = this.repo.load(this.cwd, this.paths, this.loadOptions());
-    this.applyLoaded(loaded);
-  }
-
-  paint() {
-    if (!this.uiOpen) return;
-    this.draw();
-  }
-
-  viewStatus() {
-    if (this.status) return this.status;
-    return this.busy;
-  }
-
-  finishIfEmpty(kind) {
-    if (this.items.length) return;
-    if (this.notes && hasNotes(this.notes)) return;
-    if (kind === 'keep') return;
-    if (this.notes && hasNotes(this.notes)) this.flushReview();
-    this.done = true;
-    this.exitCode = 0;
-    this.status = 'nothing to review';
-    this.emptyReview = kind === 'open';
-    if (this.finishReadLoop) this.finishReadLoop();
-  }
-
-  failOpen(error) {
-    if (isAbortError(error)) return;
-    this.loadError = error;
-    this.done = true;
-    this.exitCode = 1;
-    this.busy = '';
-    this.stopProgress();
-    if (this.finishReadLoop) this.finishReadLoop();
-  }
-
-  async followExtras(loaded, gen, kind) {
-    if (!this.repo.loadExtras) {
-      this.clearBusy();
-      this.pendingExtras = false;
-      this.paint();
-      this.finishIfEmpty(kind);
-      return;
-    }
-    const signal = this.loadAbort ? this.loadAbort.signal : undefined;
-    const extra = this.loadOptions({
-      paths: this.paths,
-      signal,
-    });
-    let next;
-    try {
-      next = await this.repo.loadExtras(loaded, extra);
-    } catch (error) {
-      if (gen !== this.loadGen) return;
-      this.failOpen(error);
-      return;
-    }
-    if (gen !== this.loadGen || this.done) return;
-    this.applyLoaded(next);
-    this.clearBusy();
-    this.paint();
-    this.finishIfEmpty(kind);
-  }
-
-  openLoad() {
-    if (this.loadPromise) return this.loadPromise;
-    if (this.didLoad && !this.pendingExtras) {
-      this.loadPromise = Promise.resolve();
-      return this.loadPromise;
-    }
-    this.bumpLoad();
-    this.loadPromise = this.runOpenLoad();
-    return this.loadPromise;
-  }
-
-  async runOpenLoad() {
-    const gen = this.loadGen;
-    const signal = this.loadAbort.signal;
-    const options = this.loadOptions({
-      deferExtras: this.shouldDeferExtras(),
-      signal,
-    });
-    this.progressFrame = 0;
-    this.setBusy('loading');
-    this.paint();
-    let loaded;
-    try {
-      if (this.repo.loadAsync) {
-        loaded = await this.repo.loadAsync(this.cwd, this.paths, options);
-      } else {
-        loaded = this.repo.load(this.cwd, this.paths, options);
-      }
-    } catch (error) {
-      if (gen !== this.loadGen) return;
-      this.failOpen(error);
-      return;
-    }
-    if (gen !== this.loadGen || this.done) return;
-    this.applyLoaded(loaded);
-    if (loaded.pending) {
-      this.setBusy('checking npm');
-      this.paint();
-      await this.followExtras(loaded, gen, 'open');
-      return;
-    }
-    this.clearBusy();
-    this.paint();
-    this.finishIfEmpty('open');
-  }
-
-  async loadReady() {
-    this.ensureRepo();
-    await this.openLoad();
-    if (this.loadError) throw this.loadError;
-  }
-
-  updateOptions() {
-    if (!this.updateOpts || this.updateOpts === true) return {};
-    return this.updateOpts;
-  }
-
-  maybePromptUpdate() {
-    if (!this.updateOffer) return;
-    if (!this.didLoad) return;
-    if (this.mode !== 'review') return;
-    this.mode = 'confirmUpdate';
-  }
-
-  openUpdate() {
-    if (this.updateOpts === false) return Promise.resolve();
-    if (this.updatePromise) return this.updatePromise;
-    this.updatePromise = this.runOpenUpdate();
-    return this.updatePromise;
-  }
-
-  async runOpenUpdate() {
-    let plan;
-    try {
-      plan = await checkUpdate(this.updateOptions());
-    } catch {
-      return;
-    }
-    if (this.done) return;
-    if (plan.action === 'install') {
-      this.installPromise = this.runInstall(plan.latest);
-      await this.installPromise;
-      return;
-    }
-    if (plan.action !== 'confirm') return;
-    this.updateFrom = plan.current;
-    this.updateTo = plan.latest;
-    this.updateOffer = true;
-    this.paint();
-  }
-
-  async runInstall(version) {
-    this.status = 'updating reslop';
-    this.progressFrame = 0;
-    this.startProgress();
-    this.paint();
-    let ok = false;
-    try {
-      await installUpdate(version, this.updateOptions());
-      ok = true;
-    } catch {
-      // ignore install errors
-    }
-    this.stopProgress();
-    if (this.done || !this.uiOpen) return;
-    this.status = ok ? 'updated' : 'update failed';
-    this.paint();
-  }
-
-  onConfirmUpdate(key) {
-    const updateKey = key.length === 1 ? key.toLowerCase() : key;
-    const handler = UPDATE_CONFIRM[updateKey];
-    if (handler) handler(this);
-  }
-
-  acceptUpdate() {
-    this.mode = 'review';
-    this.updateOffer = false;
-    const version = this.updateTo;
-    this.installPromise = this.runInstall(version);
-  }
-
-  declineUpdate() {
-    this.mode = 'review';
-    this.updateOffer = false;
-    this.status = '';
-    markSkipped(this.updateTo, this.updateOptions());
-  }
-
-  initReview() {
-    const names = listReviewNames(this.top, this.readdirSync);
-    const templates = loadTemplates(this.top, this.readFileSync);
-    const resolved = resolveReviewPath(this.top, this.now(), names, {
-      forceNew: this.forceNewReview,
-      readFileSync: this.readFileSync,
-    });
-    if (resolved.resume) {
-      this.notes = loadReview(
-        resolved.reviewPath,
-        templates,
-        this.readFileSync,
-      );
-      this.didResumeReview = true;
-      return;
-    }
-    this.notes = createStore(resolved.reviewPath, templates);
-  }
-
-  repoNameOf() {
-    return this.repoName || path.basename(this.top || this.cwd || '');
-  }
-
-  todosEntry() {
-    const notes = noteCounts(this.notes);
-    return {
-      path: REPO_TODOS_LABEL,
-      kind: 'todos',
-      status: 'todos',
-      remaining: notes.todo,
-      staged: notes.todoDone,
-      firstIndex: 0,
-      openIndex: 0,
-      added: 0,
-      removed: 0,
-      unstaged: 0,
-    };
-  }
-
-  clampIndex() {
-    if (!this.items.length) {
-      this.index = 0;
-      return;
-    }
-    if (this.index < 0) this.index = 0;
-    if (this.index >= this.items.length) {
-      this.index = this.items.length - 1;
-    }
-  }
-
-  fileList() {
-    const entries = fileEntries(this.items);
-    const labeled = this.sourceLabel
-      ? relabelStatus(entries, 'pr', this.sourceLabel)
-      : relabelStatus(entries, 'commit', this.revShort);
-    return [this.todosEntry(), ...labeled];
-  }
-
-  syncReviewPath() {
-    if (this.pane !== 'diff') return;
-    const item = this.current();
-    this.reviewPath = item ? itemPath(item) : null;
-  }
-
-  clampFileCursor() {
-    const files = this.fileList();
-    if (!files.length) {
-      this.fileCursor = 0;
-      return;
-    }
-    if (this.fileCursor >= files.length) {
-      this.fileCursor = files.length - 1;
-    }
-  }
-
-  followReviewPath() {
-    const files = this.fileList();
-    if (!files.length) {
-      this.fileCursor = 0;
-      return;
-    }
-    const item = this.current();
-    const idx = isTodoItem(item)
-      ? files.findIndex((entry) => isTodosEntry(entry))
-      : files.findIndex(
-          (entry) => !isTodosEntry(entry) && entry.path === this.reviewPath,
-        );
-    if (idx >= 0) {
-      this.fileCursor = idx;
-      return;
-    }
-    this.clampFileCursor();
-  }
-
-  syncFileCursor() {
-    if (this.pane === 'files') {
-      this.clampFileCursor();
-      return;
-    }
-    this.followReviewPath();
-  }
-
-  counts() {
-    const counts = {
-      staged: 0,
-      unstaged: 0,
-      untracked: 0,
-      commit: 0,
-      pr: 0,
-      todo: 0,
-      feedback: 0,
-      code: 0,
-    };
-    for (const item of this.items) {
-      if (!Object.hasOwn(counts, item.origin)) continue;
-      counts[item.origin] += 1;
-    }
-    const notes = noteCounts(this.notes);
-    counts.feedback = notes.feedback;
-    counts.todo = notes.todo;
-    counts.code = notes.code;
-    return counts;
-  }
-
-  view() {
-    const templates = this.shownTemplates();
-    const change = this.change;
-    const sourceKind = (change && SOURCE_KIND[change.source]) || '';
-    const repoName = this.repoNameOf();
-    return {
-      item: this.current(),
-      index: this.index,
-      total: this.items.length,
-      scroll: this.scroll,
-      status: this.viewStatus(),
-      progressFrame: this.progressFrame,
-      layout: this.layout,
-      counts: this.counts(),
-      selection: this.selection,
-      pane: this.pane,
-      files: this.fileList(),
-      fileCursor: this.fileCursor,
-      reviewPath: this.reviewPath,
-      branch: this.branch,
-      branches: this.branches,
-      branchCursor: this.branchCursor,
-      repoName,
-      revShort: this.revShort || '',
-      sourceLabel: this.sourceLabel || '',
-      sourceKind,
-      mode: this.mode,
-      compose: this.composeView(),
-      noteText: this.idleNoteText(),
-      todos: this.todoTexts(),
-      todoFocus: this.clampedTodoFocus(),
-      todoEdit: this.todoEditView(),
-      codeOverlay: this.codeOverlayView(),
-      templates,
-      templateIndex: this.clampedTemplateIndex(templates),
-      updateFrom: this.updateFrom,
-      updateTo: this.updateTo,
-      dropName: this.dropName,
-    };
-  }
-
-  draw() {
-    this.maybePromptUpdate();
-    const size = this.getSize();
-    const resized =
-      !this.lastSize ||
-      this.lastSize.width !== size.width ||
-      this.lastSize.height !== size.height;
-    const frame = renderFrame(this.view(), {
-      width: size.width,
-      height: size.height,
-      color: this.color,
-    });
-    const composing = this.mode === 'compose';
-    const cursor = composing && this.blinkOn ? frame.cursor : null;
-    if (!resized && this.lastFrame && this.lastFrame.text === frame.text) {
-      if (sameCursor(this.lastPresentedCursor, cursor)) return;
-      this.lastPresentedCursor = cursor;
-      this.stdout.write(presentCursor(cursor));
-      return;
-    }
-    this.lastSize = size;
-    this.lastFrame = frame;
-    this.lastPresentedCursor = cursor;
-    this.stdout.write(presentRows(frame.rows, { clear: resized, cursor }));
-  }
-
-  dispatch(action) {
-    if (CONFIRM_MODE.includes(this.mode)) return;
-    if (this.mode === 'compose') {
-      if (!COMPOSE_LEAVE.includes(action)) return;
-      this.commitCompose();
-      this.closeCompose();
-    }
-    if (this.pane === 'files') {
-      if (action === 'next') return void this.onFileMove(1);
-      if (action === 'prev') return void this.onFileMove(-1);
-    }
-    if (this.pane === 'branches') {
-      if (action === 'next') return void this.onBranchMove(1);
-      if (action === 'prev') return void this.onBranchMove(-1);
-    }
-    let target = this.current();
-    if (this.pane === 'files') target = this.fileCursorEntry();
-    if (this.pane === 'branches') target = this.branches[this.branchCursor];
-    const hidden = disabledActions(this.pane, target);
-    if (hidden.includes(action)) return;
-    const handler = HANDLERS[action];
-    if (!handler) return;
-    handler(this);
-  }
-
-  current() {
-    if (this.todoOpen) return this.todoItem;
-    return this.items[this.index] ?? null;
-  }
-
-  refreshFromRepo(options = {}) {
-    this.loadPromise = null;
-    this.bumpLoad();
-    if (this.uiOpen && this.repo.loadAsync) {
-      return void this.refreshFromRepoAsync(options);
-    }
-    const loadedOpts = this.loadOptions({
-      deferExtras: this.shouldDeferExtras(),
-    });
-    const loaded = this.repo.load(this.cwd, this.paths, loadedOpts);
-    this.applyLoaded(loaded);
-    this.scroll = 0;
-    this.clearSelection();
-    if (options.afterLoad) options.afterLoad();
-    const keepEmpty = options.keepEmpty === true;
-    if (loaded.pending) {
-      this.setBusy('checking npm');
-      const kind = keepEmpty ? 'keep' : 'reload';
-      this.followExtras(loaded, this.loadGen, kind);
-      return;
-    }
-    if (keepEmpty) return;
-    this.finishIfEmpty('reload');
-    if (options.doneStatus && !this.done && !this.pendingExtras) {
-      this.status = options.doneStatus;
-    }
-  }
-
-  async refreshFromRepoAsync(options = {}) {
-    const gen = this.loadGen;
-    const keepEmpty = options.keepEmpty === true;
-    const loadedOpts = this.loadOptions({
-      deferExtras: this.shouldDeferExtras(),
-      signal: this.loadAbort ? this.loadAbort.signal : undefined,
-    });
-    this.progressFrame = 0;
-    this.setBusy('loading');
-    this.paint();
-    let loaded;
-    try {
-      loaded = await this.repo.loadAsync(this.cwd, this.paths, loadedOpts);
-    } catch (error) {
-      if (gen !== this.loadGen) return;
-      this.failOpen(error);
-      return;
-    }
-    if (gen !== this.loadGen || this.done) return;
-    this.applyLoaded(loaded);
-    this.scroll = 0;
-    this.clearSelection();
-    if (options.afterLoad) options.afterLoad();
-    if (loaded.pending) {
-      this.setBusy('checking npm');
-      const kind = keepEmpty ? 'keep' : 'reload';
-      await this.followExtras(loaded, gen, kind);
-      return;
-    }
-    this.clearBusy();
-    if (!keepEmpty) this.finishIfEmpty('reload');
-    if (options.doneStatus && !this.status && !this.busy) {
-      this.status = options.doneStatus;
-    }
-    this.paint();
-  }
-
-  reloadAfterChange(afterLoad) {
-    const here = this.index;
-    const restore = () => {
-      this.index = here;
-      this.clampIndex();
-      this.syncReviewPath();
-      this.syncFileCursor();
-      if (afterLoad) afterLoad();
-    };
-    if (this.uiOpen && this.repo.loadAsync) {
-      this.refreshFromRepo({ afterLoad: restore });
-      return;
-    }
-    this.refreshFromRepo();
-    restore();
-  }
-
-  onReload() {
-    this.dismissed.clear();
-    this.status = '';
-    this.refreshFromRepo({ doneStatus: 'reloaded' });
-  }
-
-  clearSelection() {
-    this.selection = null;
-    this.mouseAnchor = null;
-    this.dragging = false;
-    this.pendingClick = null;
-  }
-
-  applyGit(item, label, write, after) {
-    try {
-      write(this.top, item);
-      this.status = label;
-      after();
-    } catch (error) {
-      this.status = error.message;
-    }
-  }
-
-  keepOrigin(item, origin) {
-    item.origin = origin;
-    if (!item.dep) refreshIndexPatches(this.items, item);
-    this.clearSelection();
-    this.syncReviewPath();
-    this.syncFileCursor();
-  }
-
-  activeDiffItem() {
-    const item = this.current();
-    if (!item) return null;
-    if (isTodoItem(item)) {
-      this.status = 'not a diff block';
-      return null;
-    }
-    return item;
-  }
-
-  fileCursorEntry() {
-    const files = this.fileList();
-    return files[this.fileCursor] ?? null;
-  }
-
-  fileActionItems() {
-    const entry = this.fileCursorEntry();
-    if (!entry || isTodosEntry(entry)) return [];
-    const rel = entry.path;
-    const items = [];
-    for (const item of this.items) {
-      if (isTodoItem(item)) continue;
-      if (itemPath(item) !== rel) continue;
-      items.push(item);
-    }
-    return items;
-  }
-
-  guardWritable(item) {
-    if (!item) return false;
-    if (this.readOnly || isReadOnlyOrigin(item.origin)) {
-      this.status = 'read only';
-      return false;
-    }
-    return true;
-  }
-
-  guardFileGit(items) {
-    if (!items.length) return false;
-    return this.guardWritable(items[0]);
-  }
-
-  applyFileGit(items, label, write, afterItem) {
-    try {
-      for (const item of items) {
-        write(this.top, item);
-        afterItem(item);
-      }
-      this.status = label;
-      return true;
-    } catch (error) {
-      this.status = error.message;
-      return false;
-    }
-  }
-
-  selectNextFileAfter(rel) {
-    const files = this.fileList();
-    if (!files.length) {
-      this.fileCursor = 0;
-      this.reviewPath = null;
-      return;
-    }
-    const idx = files.findIndex((entry) => entry.path === rel);
-    let at = idx < 0 ? this.fileCursor : idx + 1;
-    if (at >= files.length) at = files.length - 1;
-    const entry = files[at];
-    this.fileCursor = at;
-    this.reviewPath = entry.path;
-    this.index = entry.firstIndex;
-  }
-
-  onFileAdd() {
-    const items = this.fileActionItems();
-    if (!items.length) {
-      this.status = 'not a diff block';
-      return;
-    }
-    if (!this.guardFileGit(items)) return;
-    const rel = itemPath(items[0]);
-    const targets = items.filter((item) => item.origin !== 'staged');
-    if (!targets.length) {
-      this.status = 'already staged';
-      this.selectNextFileAfter(rel);
-      return;
-    }
-    const proposed = targets.some((item) => needsReload(item));
-    const busy = targets.map(npmBusyKind).find((kind) => kind);
-    if (this.uiOpen && busy && this.repo.addAsync) {
-      const write = async (top) => {
-        for (const item of targets) {
-          await this.repo.addAsync(top, item);
-          this.keepOrigin(item, 'staged');
-        }
-      };
-      const after = () => {
-        if (proposed) {
-          this.reloadAfterChange(() => this.selectNextFileAfter(rel));
-          return;
-        }
-        this.selectNextFileAfter(rel);
-      };
-      return void this.runGitBusy(busy, 'staged', write, after);
-    }
-    const ok = this.applyFileGit(
-      targets,
-      'staged',
-      (top, current) => this.repo.add(top, current),
-      (item) => this.keepOrigin(item, 'staged'),
-    );
-    if (ok && proposed) this.reloadAfterChange();
-    if (ok) this.selectNextFileAfter(rel);
-  }
-
-  onFileUnstage() {
-    const items = this.fileActionItems();
-    if (!items.length) {
-      this.status = 'not a diff block';
-      return;
-    }
-    if (!this.guardFileGit(items)) return;
-    const rel = itemPath(items[0]);
-    const targets = items.filter((item) => item.origin === 'staged');
-    if (!targets.length) {
-      this.status = 'not staged';
-      this.selectNextFileAfter(rel);
-      return;
-    }
-    const ok = this.applyFileGit(
-      targets,
-      'unstaged',
-      (top, current) => this.repo.unstage(top, current),
-      (item) => {
-        const origin = item.file.isNew === true ? 'untracked' : 'unstaged';
-        this.keepOrigin(item, origin);
-      },
-    );
-    if (ok) this.selectNextFileAfter(rel);
-  }
-
-  onFileRevert() {
-    const items = this.fileActionItems();
-    if (!items.length) {
-      this.status = 'not a diff block';
-      return;
-    }
-    if (!this.guardFileGit(items)) return;
-    const rel = itemPath(items[0]);
-    for (const item of items) {
-      if (needsReload(item)) this.dismissed.add(itemKey(item));
-    }
-    let ok = false;
-    try {
-      this.repo.revertFile(this.top, rel, items);
-      this.status = 'dropped';
-      ok = true;
-    } catch (error) {
-      this.status = error.message;
-    }
-    this.reloadAfterChange(ok ? () => this.selectNextFileAfter(rel) : null);
-  }
-
-  onAdd() {
-    if (this.pane === 'files') return void this.onFileAdd();
-    const item = this.activeDiffItem();
-    if (!this.guardWritable(item)) return;
-    if (item.origin === 'staged') {
-      this.status = 'already staged';
-      return;
-    }
-    const busy = npmBusyKind(item);
-    if (this.uiOpen && busy && this.repo.addAsync) {
-      const after = () => {
-        if (needsReload(item)) this.reloadAfterChange();
-        else this.keepOrigin(item, 'staged');
-      };
-      const write = (top) => this.repo.addAsync(top, item);
-      return void this.runGitBusy(busy, 'staged', write, after);
-    }
-    this.applyGit(
-      item,
-      'staged',
-      (top, current) => this.repo.add(top, current),
-      () => {
-        if (needsReload(item)) {
-          this.reloadAfterChange();
-          return;
-        }
-        this.keepOrigin(item, 'staged');
-      },
-    );
-  }
-
-  onUnstage() {
-    if (this.pane === 'files') return void this.onFileUnstage();
-    const item = this.activeDiffItem();
-    if (!this.guardWritable(item)) return;
-    if (item.origin !== 'staged') {
-      this.status = 'not staged';
-      return;
-    }
-    const origin = item.file.isNew === true ? 'untracked' : 'unstaged';
-    this.applyGit(
-      item,
-      'unstaged',
-      (top, current) => this.repo.unstage(top, current),
-      () => this.keepOrigin(item, origin),
-    );
-  }
-
-  onRevert() {
-    if (this.pane === 'files') return void this.onFileRevert();
-    const item = this.activeDiffItem();
-    if (!this.guardWritable(item)) return;
-    this.applyGit(
-      item,
-      'dropped',
-      (top, current) => this.repo.revert(top, current),
-      () => {
-        if (needsReload(item)) this.dismissed.add(itemKey(item));
-        this.reloadAfterChange();
-      },
-    );
-  }
-
-  moveRemaining(step) {
-    if (!this.items.length) {
-      this.status = 'nothing to review';
-      return;
-    }
-    const next = this.index + step;
-    if (next < 0 || next >= this.items.length) return;
-    this.index = next;
-    this.scroll = 0;
-    this.status = '';
-    this.clearSelection();
-    this.syncReviewPath();
-  }
-
-  onNext() {
-    if (this.todoOpen) {
-      this.closeTodoPage();
-      if (this.items.length) this.index = 0;
-      this.scroll = 0;
-      this.syncReviewPath();
-      this.syncFileCursor();
-      return;
-    }
-    this.moveRemaining(1);
-  }
-
-  onPrev() {
-    if (this.todoOpen) return;
-    if (this.index <= 0) {
-      this.openTodoPage();
-      return;
-    }
-    this.moveRemaining(-1);
-  }
-
-  onQuit() {
-    if (this.mode === 'compose') {
-      this.commitCompose();
-      this.closeCompose();
-    }
-    if (hasNotes(this.notes)) {
-      this.mode = 'confirmQuit';
-      this.status = '';
-      return;
-    }
-    this.done = true;
-    this.exitCode = 0;
-  }
-
-  finishQuit(status) {
-    if (this.notes) {
-      this.notes.status = status;
-      this.notes.dirty = true;
-    }
-    this.flushReview();
-    this.done = true;
-    this.exitCode = 0;
-  }
-
-  cancelQuit() {
-    this.mode = 'review';
-    this.status = '';
-  }
-
-  onConfirmQuit(key) {
-    const quitKey = key.length === 1 ? key.toLowerCase() : key;
-    const handler = QUIT_CONFIRM[quitKey];
-    if (handler) handler(this);
-  }
-
-  canCommit() {
-    if (this.readOnly || this.rev || this.change) {
-      this.status = 'read only';
-      return false;
-    }
-    for (const item of this.items) {
-      if (isReadOnlyOrigin(item.origin)) {
-        this.status = 'read only';
-        return false;
-      }
-    }
-    return true;
-  }
-
-  onCommit() {
-    if (!this.canCommit()) return;
-    this.mode = 'confirmCommit';
-    this.status = '';
-  }
-
-  cancelCommit() {
-    this.mode = 'review';
-    this.commitKind = null;
-    this.status = '';
-  }
-
-  startGitCommit(kind) {
-    if (kind !== 'amend' && !this.hasStagedChanges()) {
-      this.mode = 'review';
-      this.commitKind = null;
-      this.status = 'nothing to commit';
-      return;
-    }
-    this.commitKind = kind;
-    let text = '';
-    if (kind === 'fixup') text = 'HEAD';
-    if (kind === 'amend' && this.repo.lastMessage) {
-      text = this.repo.lastMessage(this.top) ?? '';
-    }
-    this.openCompose('commit', text);
-  }
-
-  hasStagedChanges() {
-    if (this.repo.hasStaged) return this.repo.hasStaged(this.top);
-    for (const item of this.items) {
-      if (item.origin === 'staged') return true;
-    }
-    return false;
-  }
-
-  onConfirmCommit(key) {
-    const commitKey = key.length === 1 ? key.toLowerCase() : key;
-    const handler = COMMIT_CONFIRM[commitKey];
-    if (handler) handler(this);
-  }
-
-  finishGitCommit() {
-    const kind = this.commitKind;
-    const message = this.editor ? this.editor.text : '';
-    if (kind !== 'fixup' && !message.trim()) {
-      this.status = 'empty commit message';
-      return;
-    }
-    if (kind !== 'amend' && !this.hasStagedChanges()) {
-      this.closeCompose();
-      this.status = 'nothing to commit';
-      return;
-    }
-    const done = COMMIT_STATUS[kind] ?? 'committed';
-    if (this.uiOpen && this.repo.commitAsync) {
-      this.closeCompose();
-      const write = (top) => this.repo.commitAsync(top, kind, message);
-      const after = () => {
-        this.dismissed.clear();
-        this.refreshFromRepo({ doneStatus: done });
-      };
-      return void this.runGitBusy('committing', done, write, after);
-    }
-    try {
-      this.repo.commit(this.top, kind, message);
-    } catch (error) {
-      this.status = error.message;
-      return;
-    }
-    this.closeCompose();
-    this.dismissed.clear();
-    this.refreshFromRepo();
-    if (!this.done && !this.pendingExtras) this.status = done;
-  }
-
-  startProgress() {
-    if (this.progressTimer !== null) return;
-    this.progressTimer = this.setInterval(
-      () => this.tickProgress(),
-      PROGRESS_MS,
-    );
-  }
-
-  stopProgress() {
-    if (this.progressTimer === null) return;
-    this.clearInterval(this.progressTimer);
-    this.progressTimer = null;
-  }
-
-  tickProgress() {
-    this.progressFrame += 1;
-    this.paint();
-  }
-
-  setBusy(kind) {
-    this.busy = kind;
-    this.startProgress();
-  }
-
-  clearBusy() {
-    this.busy = '';
-    this.stopProgress();
-  }
-
-  async runGitBusy(kind, done, write, after) {
-    if (this.gitBusy) return;
-    this.gitBusy = true;
-    this.status = '';
-    this.progressFrame = 0;
-    this.setBusy(kind);
-    this.paint();
-    try {
-      await write(this.top);
-    } catch (error) {
-      if (error.rejected && kind !== 'force pushing') {
-        this.mode = 'confirmPush';
-      } else {
-        this.status = error.message;
-      }
-    }
-    this.clearBusy();
-    this.gitBusy = false;
-    if (this.done) {
-      this.paint();
-      return;
-    }
-    if (this.mode === 'confirmPush') {
-      this.paint();
-      return;
-    }
-    if (!this.status && after) after();
-    if (!this.status && !this.busy) this.status = done;
-    this.paint();
-  }
-
-  runRepo(label, write) {
-    try {
-      write(this.top);
-      this.status = label;
-      return true;
-    } catch (error) {
-      this.status = error.message;
-      return false;
-    }
-  }
-
-  onBranch() {
-    if (this.mode === 'compose') return;
-    if (!this.canCommit()) return;
-    if (!this.repo.listBranches) {
-      this.status = 'read only';
-      return;
-    }
-    try {
-      this.branches = this.repo.listBranches(this.top);
-    } catch (error) {
-      this.status = error.message;
-      return;
-    }
-    const current = this.branches.findIndex((entry) => entry.current);
-    this.branchCursor = current < 0 ? 0 : current;
-    this.pane = 'branches';
-    this.status = '';
-    this.clearSelection();
-  }
-
-  onBranchMove(delta) {
-    const branches = this.branches;
-    if (!branches.length) {
-      this.status = 'nothing to review';
-      return;
-    }
-    const next = Math.min(
-      branches.length - 1,
-      Math.max(0, this.branchCursor + delta),
-    );
-    if (next === this.branchCursor) return;
-    this.branchCursor = next;
-    this.status = '';
-  }
-
-  onCheckoutBranch() {
-    if (!this.canCommit()) return;
-    const entry = this.branches[this.branchCursor];
-    if (!entry) return;
-    if (entry.current) {
-      this.showFiles();
-      return;
-    }
-    const name = entry.name;
-    const done = `checked out ${name}`;
-    if (this.uiOpen && this.repo.checkoutAsync) {
-      this.showFiles();
-      const write = (top) => this.repo.checkoutAsync(top, name);
-      const after = () =>
-        this.refreshFromRepo({ keepEmpty: true, doneStatus: done });
-      return void this.runGitBusy('checking out', done, write, after);
-    }
-    const ok = this.runRepo(done, (top) => {
-      this.repo.checkout(top, name);
-    });
-    if (!ok) return;
-    this.showFiles();
-    this.refreshFromRepo({ keepEmpty: true });
-    if (!this.status) this.status = done;
-  }
-
-  refreshBranchList() {
-    if (!this.repo.listBranches) return;
-    try {
-      this.branches = this.repo.listBranches(this.top);
-    } catch (error) {
-      this.status = error.message;
-      return;
-    }
-    const last = this.branches.length - 1;
-    if (this.branchCursor > last) this.branchCursor = Math.max(0, last);
-  }
-
-  onRebaseBranch() {
-    if (this.pane !== 'branches') return;
-    if (!this.canCommit()) return;
-    const entry = this.branches[this.branchCursor];
-    if (!entry || entry.current) return;
-    const onto = entry.name;
-    const done = `rebased onto ${onto}`;
-    if (this.uiOpen && this.repo.rebaseAsync) {
-      const write = (top) => this.repo.rebaseAsync(top, onto);
-      const after = () => {
-        this.refreshBranchList();
-        this.refreshFromRepo({ keepEmpty: true, doneStatus: done });
-      };
-      return void this.runGitBusy('rebasing', done, write, after);
-    }
-    const ok = this.runRepo(done, (top) => this.repo.rebase(top, onto));
-    if (!ok) return;
-    this.refreshBranchList();
-    this.refreshFromRepo({ keepEmpty: true });
-    if (!this.status) this.status = done;
-  }
-
-  onDropBranch() {
-    if (this.pane !== 'branches') return;
-    if (!this.canCommit()) return;
-    const entry = this.branches[this.branchCursor];
-    if (!entry || entry.current) return;
-    this.dropName = entry.name;
-    this.mode = 'confirmDrop';
-    this.status = '';
-  }
-
-  onConfirmDrop(key) {
-    const dropKey = key.length === 1 ? key.toLowerCase() : key;
-    const handler = DROP_CONFIRM[dropKey];
-    if (handler) handler(this);
-  }
-
-  cancelDropBranch() {
-    this.mode = 'review';
-    this.dropName = '';
-    this.status = '';
-  }
-
-  confirmDropBranch() {
-    const name = this.dropName;
-    this.mode = 'review';
-    this.dropName = '';
-    if (!name) return;
-    const done = `dropped ${name}`;
-    if (this.uiOpen && this.repo.dropAsync) {
-      const write = (top) => this.repo.dropAsync(top, name);
-      const after = () => {
-        this.refreshBranchList();
-        this.refreshFromRepo({ keepEmpty: true, doneStatus: done });
-      };
-      return void this.runGitBusy('dropping', done, write, after);
-    }
-    const ok = this.runRepo(done, (top) => this.repo.drop(top, name));
-    if (!ok) return;
-    this.refreshBranchList();
-    this.refreshFromRepo({ keepEmpty: true });
-    if (!this.status) this.status = done;
-  }
-
-  onNewBranch() {
-    if (this.pane !== 'branches') return;
-    if (!this.canCommit()) return;
-    this.openCompose('branch', '');
-  }
-
-  finishCreateBranch() {
-    const name = this.editor ? this.editor.text.trim() : '';
-    if (!name) {
-      this.status = 'empty branch name';
-      return;
-    }
-    const done = `created ${name}`;
-    if (this.uiOpen && this.repo.createBranchAsync) {
-      this.closeCompose();
-      this.showFiles();
-      const write = (top) => this.repo.createBranchAsync(top, name);
-      const after = () =>
-        this.refreshFromRepo({ keepEmpty: true, doneStatus: done });
-      return void this.runGitBusy('creating branch', done, write, after);
-    }
-    const ok = this.runRepo(done, (top) => {
-      this.repo.createBranch(top, name);
-    });
-    if (!ok) return;
-    this.closeCompose();
-    this.showFiles();
-    this.refreshFromRepo({ keepEmpty: true });
-    if (!this.status) this.status = done;
-  }
-
-  onPull() {
-    if (!this.canCommit()) return;
-    if (this.repo.pullAsync) {
-      const after = () => this.refreshFromRepo({ keepEmpty: true });
-      const write = (top) => this.repo.pullAsync(top);
-      return void this.runGitBusy('pulling', 'pulled', write, after);
-    }
-    const ok = this.runRepo('pulled', (top) => this.repo.pull(top));
-    if (!ok) return;
-    this.refreshFromRepo({ keepEmpty: true });
-    if (!this.status) this.status = 'pulled';
-  }
-
-  onPush() {
-    this.startPush(false);
-  }
-
-  onForcePush() {
-    this.mode = 'review';
-    this.startPush(true);
-  }
-
-  cancelPush() {
-    this.mode = 'review';
-    this.status = '';
-  }
-
-  onConfirmPush(key) {
-    const pushKey = key.length === 1 ? key.toLowerCase() : key;
-    const handler = PUSH_CONFIRM[pushKey];
-    if (handler) handler(this);
-  }
-
-  startPush(force) {
-    if (!this.canCommit()) return;
-    const done = force ? 'force pushed' : 'pushed';
-    const kind = force ? 'force pushing' : 'pushing';
-    if (this.repo.pushAsync) {
-      const write = (top) => this.repo.pushAsync(top, force);
-      return void this.runGitBusy(kind, done, write);
-    }
-    try {
-      this.repo.push(this.top, force);
-    } catch (error) {
-      if (error.rejected && !force) {
-        this.mode = 'confirmPush';
-        this.status = '';
-        return;
-      }
-      this.status = error.message;
-      return;
-    }
-    this.status = done;
-  }
-
-  onFeedback() {
-    if (this.pane === 'files') {
-      this.status = 'not a diff block';
-      return;
-    }
-    const item = this.current();
-    if (!item || isTodoItem(item)) {
-      this.status = 'not a diff block';
-      return;
-    }
-    const prev = this.notes.feedback.get(itemFeedKey(item));
-    const text = prev ? prev.text : '';
-    this.openCompose('feedback', text);
-  }
-
-  onTodo() {
-    if (this.pane === 'files') {
-      const entry = this.fileCursorEntry();
-      if (entry && !isTodosEntry(entry)) {
-        this.index = entry.openIndex ?? entry.firstIndex;
-      }
-    }
-    this.createTodo();
-  }
-
-  onCode() {
-    if (this.pane === 'files') {
-      this.status = 'not a diff block';
-      return;
-    }
-    const item = this.current();
-    if (!canEditCode(item)) {
-      this.status = 'not a diff block';
-      return;
-    }
-    const prev = this.notes.code.get(itemFeedKey(item));
-    const original = blockAddText(item.hunk, item.blockId);
-    const text = prev ? prev.text : original;
-    this.openCompose('code', text);
-  }
-
-  focusTodoPage(todoId) {
-    this.openTodoPage();
-    const todos = this.listTodos();
-    let focus = 0;
-    if (todoId === null) {
-      focus = todos.length;
-    } else if (todoId !== undefined) {
-      const at = todos.findIndex((todo) => todo.id === todoId);
-      if (at >= 0) focus = at;
-      else if (todos.length) focus = todos.length - 1;
-    }
-    this.todoFocus = focus;
-    this.scroll = 0;
-    return true;
-  }
-
-  isDraftCompose() {
-    return (
-      this.mode === 'compose' &&
-      this.composeKind === 'todo' &&
-      this.composeTodoId === null
-    );
-  }
-
-  openTodoPage() {
-    this.todoOpen = true;
-    this.pane = 'diff';
-    this.scroll = 0;
-    this.clearSelection();
-    this.syncReviewPath();
-  }
-
-  closeTodoPage() {
-    this.todoOpen = false;
-    this.syncReviewPath();
-    this.syncFileCursor();
-  }
-
-  startDraftCompose() {
-    this.focusTodoPage(null);
-    this.openCompose('todo', '', null);
-  }
-
-  editFocusedTodo() {
-    if (!this.todoOpen) return;
-    const todos = this.listTodos();
-    const focus = this.clampedTodoFocus();
-    const todo = todos[focus];
-    if (!todo) {
-      this.startDraftCompose();
-      return;
-    }
-    this.openCompose('todo', todo.text, todo.id);
-  }
-
-  editNextTodo() {
-    if (!this.todoOpen) return;
-    const last = this.todoRowCount() - 1;
-    const next = this.clampedTodoFocus() + 1;
-    if (next <= last) this.todoFocus = next;
-    this.editFocusedTodo();
-  }
-
-  moveTodoCompose(delta) {
-    if (!this.todoOpen) return;
-    const last = this.todoRowCount() - 1;
-    const next = this.clampedTodoFocus() + delta;
-    if (next < 0 || next > last) return;
-    this.commitCompose();
-    this.flushReview();
-    this.closeCompose();
-    const max = Math.max(0, this.todoRowCount() - 1);
-    this.todoFocus = Math.min(next, max);
-    this.editFocusedTodo();
-  }
+const NAV_FIELDS = [
+  'pane',
+  'index',
+  'fileCursor',
+  'branchCursor',
+  'commitCursor',
+  'scroll',
+  'listScroll',
+  'reviewPath',
+  'selection',
+  'mouseAnchor',
+  'pendingClick',
+  'todoOpen',
+  'todoFocus',
+];
 
-  typeIntoTodo(key) {
-    if (!this.todoOpen) return false;
-    if (this.pane !== 'diff') return false;
-    if (this.mode !== 'review') return false;
-    if (!isTodoTypeKey(key)) return false;
-    this.editFocusedTodo();
-    this.editor.insert(key);
-    this.resetBlink();
-    return true;
-  }
+const COMPOSER_FIELDS = [
+  'editor',
+  'composeKind',
+  'commitKind',
+  'composeTodoId',
+  'composeBaseline',
+  'templateIndex',
+  'templateFocus',
+  'blinkOn',
+];
 
-  removeFocusedTodo() {
-    if (this.pane !== 'diff' || !this.todoOpen) return;
-    const todos = this.listTodos();
-    const focus = this.clampedTodoFocus();
-    const todo = todos[focus];
-    if (!todo) return;
-    removeTodo(this.notes, todo.id);
-    const left = this.listTodos();
-    if (this.todoFocus >= left.length) {
-      this.todoFocus = Math.max(0, left.length - 1);
-    }
-    this.flushReview(true);
-  }
+const assignOptions = (session, options) => {
+  session.repo = options.repo;
+  session.cwd = options.cwd;
+  session.paths = options.paths ?? [];
+  session.stdin = options.stdin ?? null;
+  session.stdout = options.stdout;
+  session.proc = options.proc ?? process;
+  session.color = options.color ?? true;
+  session.copyText = options.copyText ?? copyText;
+  const termSize = () => {
+    const width = session.stdout.columns ?? 80;
+    const height = session.stdout.rows ?? 24;
+    return { width, height };
+  };
+  session.getSize = options.getSize ?? termSize;
+  session.rev = options.rev ?? null;
+  session.revShort = '';
+  session.sourceLabel = options.sourceLabel ?? '';
+  session.repoName = options.repoName ?? '';
+  session.change = options.change ?? null;
+  session.now = options.now ?? systemNow;
+  session.forceNewReview = options.newReview === true;
+  session.readOnly = options.readOnly === true;
+  session.capabilities = sessionCapabilities(options);
+  const storage = options.reviewStorage ?? createReviewStorage(options);
+  session.audit = options.audit === true;
+  session.outdatedMap = options.outdatedMap;
+  session.auditMap = options.auditMap;
+  session.setInterval = options.setInterval ?? setInterval;
+  session.clearInterval = options.clearInterval ?? clearInterval;
+  session.watchOpts = {
+    watch: options.watch,
+    readdirSync: options.watchReaddir,
+    statSync: options.watchStat,
+    setTimeout: options.setTimeout ?? setTimeout,
+    clearTimeout: options.clearTimeout ?? clearTimeout,
+    debounceMs: options.watchDebounceMs,
+    recursive: options.watchRecursive,
+  };
+  session.updateOpts = options.update;
+  session.term = createTerminal({
+    stdin: session.stdin,
+    stdout: session.stdout,
+    proc: session.proc,
+    setInterval: session.setInterval,
+    clearInterval: session.clearInterval,
+  });
+  session.loader = createLoadCoordinator();
+  session.collection = createItemCollection();
+  session.nav = createNavigation({
+    startPane: options.startPane ?? 'files',
+  });
+  session.review = createReviewController({ storage });
+  session.progress = createProgress(
+    session.term,
+    () => session.tickProgress(),
+    PROGRESS_MS,
+  );
+};
 
-  onTodoHit(cursor) {
-    if (!this.todoOpen) return;
-    const todos = this.listTodos();
-    const draft = cursor === todos.length;
-    const target = todos[cursor];
-    if (!draft && !target) return;
-    if (this.mode === 'compose' && this.composeKind === 'todo') {
-      if (draft && this.composeTodoId === null) return;
-      if (target && target.id === this.composeTodoId) return;
-      this.commitCompose();
-      this.closeCompose();
-    }
-    this.todoFocus = cursor;
-    this.editFocusedTodo();
-  }
+const assignUpdater = (session) => {
+  session.updater = createUpdateCoordinator({
+    updateOpts: () => session.updateOpts,
+    didLoad: () => session.loader.didLoad,
+    getMode: () => session.mode,
+    setMode: (mode) => {
+      session.mode = mode;
+    },
+    isDone: () => session.done,
+    uiOpen: () => session.uiOpen,
+    paint: () => session.paint(),
+    setStatus: (value) => {
+      session.status = value;
+    },
+    startInstallProgress: () => {
+      session.progressFrame = 0;
+      session.progress.start('install');
+    },
+    stopInstallProgress: () => session.progress.stop('install'),
+  });
+};
 
-  createTodo() {
-    this.startDraftCompose();
-  }
+const assignComposer = (session) => {
+  session.composer = createComposer({
+    nav: session.nav,
+    review: session.review,
+    ui: session,
+    restartBlink: () => {
+      if (!session.term.hasTimer('blink')) return;
+      session.term.restartTimer(
+        'blink',
+        () => session.tickBlink(),
+        CURSOR_BLINK_MS,
+      );
+    },
+  });
+};
 
-  openCompose(kind, text, todoId) {
-    this.mode = 'compose';
-    this.composeKind = kind;
-    this.composeTodoId = todoId ?? null;
-    this.composeBaseline = text;
-    this.editor = new Editor(text);
-    this.templateIndex = -1;
-    this.templateFocus = false;
-    this.status = '';
-    this.clearSelection();
-    this.resetBlink();
-  }
+const assignControllers = (session) => {
+  const setStatus = (value) => {
+    session.status = value;
+  };
+  const setMode = (mode) => {
+    session.mode = mode;
+  };
+  session.ops = createOpsRunner({
+    top: () => session.top,
+    isDone: () => session.done,
+    getMode: () => session.mode,
+    setMode,
+    getStatus: () => session.status,
+    setStatus,
+    paint: () => session.paint(),
+    startProgress: () => session.startProgress(),
+    stopProgress: () => session.stopProgress(),
+    resetProgressFrame: () => {
+      session.progressFrame = 0;
+    },
+  });
+  session.changeActions = createChangeActions({
+    repo: () => session.repo,
+    top: () => session.top,
+    capabilities: () => session.capabilities,
+    uiOpen: () => session.uiOpen,
+    collection: session.collection,
+    getItems: () => session.items,
+    currentItem: () => session.current(),
+    nav: session.nav,
+    fileList: () => session.fileList(),
+    runBusy: session.ops.runBusy,
+    reloadAfterChange: (afterLoad) => session.reloadAfterChange(afterLoad),
+    setStatus,
+    syncReviewPath: () => session.syncReviewPath(),
+    syncFileCursor: () => session.syncFileCursor(),
+    ignoreWatch: () => session.lifecycle.ignoreWatch(),
+  });
+  session.commits = createCommitController({
+    repo: () => session.repo,
+    top: () => session.top,
+    capabilities: () => session.capabilities,
+    getItems: () => session.items,
+    uiOpen: () => session.uiOpen,
+    composer: session.composer,
+    collection: session.collection,
+    runner: session.ops,
+    refreshFromRepo: (opts) => session.refreshFromRepo(opts),
+    setMode,
+    setStatus,
+    isDone: () => session.done,
+    pendingExtras: () => session.pendingExtras,
+    getMode: () => session.mode,
+    getStatus: () => session.status,
+    nav: session.nav,
+  });
+  session.gitBranches = createBranchController({
+    repo: () => session.repo,
+    top: () => session.top,
+    capabilities: () => session.capabilities,
+    uiOpen: () => session.uiOpen,
+    composer: session.composer,
+    nav: session.nav,
+    runner: session.ops,
+    canCommit: session.commits.canCommit,
+    refreshFromRepo: (opts) => session.refreshFromRepo(opts),
+    showFiles: () => session.showFiles(),
+    getMode: () => session.mode,
+    setMode,
+    getStatus: () => session.status,
+    setStatus,
+  });
+};
 
-  commitCompose() {
-    if (this.mode !== 'compose' || !this.editor || !this.notes) return;
-    const text = this.editor.text;
-    if (this.composeKind === 'feedback') {
-      const item = this.current();
-      if (!item || isTodoItem(item)) return;
-      const hunk = item.hunk;
-      setFeedback(this.notes, itemFeedKey(item), {
-        file: itemPath(item),
-        oldStart: hunk ? hunk.oldStart : 0,
-        newStart: hunk ? hunk.newStart : 0,
-        blockId: item.blockId ?? 0,
-        origin: item.origin,
-        header: hunk ? hunk.header : '',
-        text,
-      });
-      return;
-    }
-    if (this.composeKind === 'todo') this.commitTodo(text);
-    if (this.composeKind === 'code') this.commitCode(text);
-  }
+const bindSessionAccessors = (session) => {
+  bindAccessors(session, session.nav, NAV_FIELDS);
+  bindAccessors(session, session.composer.state, COMPOSER_FIELDS);
+  bindAccessors(session, session.loader, ['pendingExtras']);
+  bindAlias(
+    session,
+    'loadPromise',
+    () => session.loader.promise,
+    (value) => {
+      session.loader.promise = value;
+    },
+  );
+  bindAccessors(session, session.collection, ['items']);
+  bindGetters(session, session.collection, ['dismissed']);
+  bindAccessors(session, session.updater, ['installPromise']);
+  bindAccessors(session, session.ops, ['gitBusy', 'busy']);
+  bindAccessors(session, session.gitBranches, ['branches', 'dropName']);
+  bindGetters(session, session.term, ['lastFrame', 'lastSize']);
+  bindAlias(session, 'loadGen', () => session.loader.gen);
+  bindAlias(
+    session,
+    'didLoad',
+    () => session.loader.didLoad,
+    (value) => {
+      session.loader.didLoad = value;
+      if (value) session.updater.maybePrompt();
+    },
+  );
+  bindAlias(session, 'notes', () => session.review.store);
+  bindAlias(session, 'didResumeReview', () => session.review.didResume);
+  bindAlias(
+    session,
+    'importedRemoteNotes',
+    () => session.review.importedRemote,
+  );
+  bindAlias(
+    session,
+    'updateOffer',
+    () => session.updater.offer,
+    (value) => {
+      session.updater.offer = value;
+    },
+  );
+  bindAlias(session, 'updateFrom', () => session.updater.from);
+  bindAlias(session, 'updateTo', () => session.updater.to);
+  bindAlias(session, 'updatePromise', () => session.updater.checkPromise);
+};
 
-  commitCode(text) {
-    const item = this.current();
-    if (!canEditCode(item)) return;
-    const original = blockAddText(item.hunk, item.blockId);
-    const key = itemFeedKey(item);
-    const hunk = item.hunk;
-    const note = {
-      file: itemPath(item),
-      oldStart: hunk.oldStart ?? 0,
-      newStart: hunk.newStart ?? 0,
-      blockId: item.blockId ?? 0,
-      origin: item.origin,
-      header: hunk.header ?? '',
-      text,
-    };
-    if (text === original) {
-      setCode(this.notes, key, { ...note, clear: true });
-      return;
-    }
-    setCode(this.notes, key, note);
-  }
+const bindViewer = (session) => {
+  session.viewer = createView({
+    nav: session.nav,
+    composer: session.composer,
+    collection: session.collection,
+    review: session.review,
+    gitBranches: session.gitBranches,
+    commits: session.commits,
+    updater: session.updater,
+    ui: session,
+  });
+};
 
-  commitTodo(text) {
-    const id = this.composeTodoId;
-    const todos = this.notes.todos;
-    const prev = id === null ? null : todos.find((entry) => entry.id === id);
-    if (prev) {
-      setTodoText(this.notes, id, text);
-      return;
-    }
-    if (!text.trim()) return;
-    const todo = addTodo(this.notes, TODO_FILE, text);
-    this.composeTodoId = todo.id;
-  }
+const bindFilesPane = (session) => {
+  session.filesPane = createFilesPane({
+    nav: session.nav,
+    composer: session.composer,
+    items: () => session.items,
+    todoItem: () => session.todoItem,
+    fileList: () => session.fileList(),
+    setStatus: (value) => {
+      session.status = value;
+    },
+    onQuit: () => session.onQuit(),
+    onCheckoutBranch: session.gitBranches.onCheckoutBranch,
+    onBranchMove: session.gitBranches.onBranchMove,
+    onCommitMove: session.commits.onCommitMove,
+    layout: () => session.layout,
+    setLayout: (value) => {
+      session.layout = value;
+    },
+    lastFrame: () => session.lastFrame,
+    getSize: () => session.lastSize ?? session.getSize(),
+  });
+};
 
-  closeCompose() {
-    this.mode = 'review';
-    this.editor = null;
-    this.composeKind = null;
-    this.commitKind = null;
-    this.composeTodoId = null;
-    this.composeBaseline = '';
-    this.templateIndex = -1;
-    this.templateFocus = false;
-    this.clampIndex();
-    this.syncReviewPath();
-    this.syncFileCursor();
-  }
+const bindLifecycle = (session) => {
+  session.lifecycle = createLifecycle({
+    loader: session.loader,
+    collection: session.collection,
+    review: session.review,
+    nav: session.nav,
+    ops: session.ops,
+    updater: session.updater,
+    loadConfig: {
+      repo: session.repo,
+      cwd: session.cwd,
+      paths: session.paths,
+      audit: session.audit,
+      outdatedMap: session.outdatedMap,
+      auditMap: session.auditMap,
+    },
+    watch: session.watchOpts,
+    ui: session,
+  });
+};
 
-  shownTemplates() {
-    if (!this.notes) return [];
-    if (this.mode === 'compose' && this.composeKind !== 'feedback') return [];
-    const ranked = rankedTemplates(this.notes.templates);
-    const editing = this.mode === 'compose' && this.editor;
-    const typed = editing ? this.editor.text : '';
-    const exact = ranked.some((entry) => entry.text === typed);
-    if (exact) return [];
-    const matched = prefixTemplates(ranked, typed);
-    return matched.slice(0, TEMPLATE_SHOW);
-  }
+const bindDispatch = (session) => {
+  const filesPane = session.filesPane;
+  session.dispatcher = createDispatcher({
+    getMode: () => session.mode,
+    getPane: () => session.pane,
+    currentTarget: () => {
+      if (session.pane === 'files') return session.fileCursorEntry();
+      if (session.pane === 'branches') {
+        return session.branches[session.branchCursor];
+      }
+      if (session.pane === 'commits') {
+        const entry = session.commits.commits[session.commitCursor];
+        const staged = targetHasStaged(session);
+        if (!entry) return { canCommit: staged };
+        return { ...entry, canCommit: staged };
+      }
+      return session.current();
+    },
+    composer: session.composer,
+    changeActions: session.changeActions,
+    commits: session.commits,
+    gitBranches: session.gitBranches,
+    onFileMove: filesPane.onFileMove,
+    onBranchMove: session.gitBranches.onBranchMove,
+    onCommitMove: session.commits.onCommitMove,
+    onNext: filesPane.onNext,
+    onPrev: filesPane.onPrev,
+    onOpenFile: filesPane.onOpenFile,
+    onFiles: filesPane.onFiles,
+    onQuit: () => session.onQuit(),
+    onLayout: filesPane.onLayout,
+    onReload: session.lifecycle.onReload,
+    onScroll: filesPane.onScroll,
+    onHome: filesPane.onHome,
+    onEnd: filesPane.onEnd,
+    scrollStep: filesPane.scrollStep,
+  });
+  session.pointer = createPointer({
+    nav: session.nav,
+    getSize: () => session.lastSize ?? session.getSize(),
+    lastFrame: () => session.lastFrame,
+    copyText: (text, stdout) => session.copyText(text, stdout),
+    stdout: () => session.stdout,
+    setStatus: (value) => {
+      session.status = value;
+    },
+    dispatch: (action) => session.dispatcher.dispatch(action),
+    getPane: () => session.pane,
+    getMode: () => session.mode,
+    confirmChoice: (key) => session.input.confirmChoice(key),
+    onBranch: session.gitBranches.onBranch,
+    onOpenFile: filesPane.onOpenFile,
+    onCheckoutBranch: session.gitBranches.onCheckoutBranch,
+    onTodoHit: (cursor) => session.composer.onTodoHit(cursor),
+    selectTemplate: (index) => session.selectTemplate(index),
+    onScroll: filesPane.onScroll,
+  });
+  session.input = createInput({
+    getMode: () => session.mode,
+    getPane: () => session.pane,
+    composer: session.composer,
+    pointer: session.pointer,
+    dispatch: (action) => session.dispatcher.dispatch(action),
+    onEscape: filesPane.onEscape,
+    onQuit: () => session.onQuit(),
+    runComposeCommand: (result) => session.runComposeCommand(result),
+    quit: {
+      ready: () => session.finishQuit('ready'),
+      editing: () => session.finishQuit('editing'),
+      cancel: () => session.cancelQuit(),
+    },
+    update: {
+      accept: session.updater.accept,
+      decline: session.updater.decline,
+    },
+    drop: {
+      confirm: () => {
+        if (session.commits.dropName) {
+          return void session.commits.confirmDropCommit();
+        }
+        session.gitBranches.confirmDropBranch();
+      },
+      cancel: () => {
+        if (session.commits.dropName) {
+          return void session.commits.cancelDropCommit();
+        }
+        session.gitBranches.cancelDropBranch();
+      },
+    },
+    push: {
+      force: session.gitBranches.onForcePush,
+      cancel: session.gitBranches.cancelPush,
+    },
+  });
+};
 
-  clampedTemplateIndex(shown) {
-    if (!shown.length) return -1;
-    if (this.templateIndex >= shown.length) return shown.length - 1;
-    return this.templateIndex;
-  }
+const composeSession = (session, options) => {
+  assignOptions(session, options);
+  assignUpdater(session);
+  assignComposer(session);
+  assignControllers(session);
+  bindSessionAccessors(session);
+  bindViewer(session);
+  bindFilesPane(session);
+  bindLifecycle(session);
+  bindDispatch(session);
+};
 
-  clearTemplatePick() {
-    this.templateIndex = -1;
-    this.templateFocus = false;
+class Session {
+  constructor(options) {
+    composeSession(this, options);
+    this.resetState();
   }
 
-  focusTemplate(index, apply) {
-    const shown = this.shownTemplates();
-    if (!shown.length) return;
-    let i = index;
-    if (i < 0) i = shown.length - 1;
-    if (i >= shown.length) i = 0;
-    this.templateIndex = i;
-    this.templateFocus = true;
-    if (apply) this.editor.replace(shown[i].text);
+  resetState() {
+    if (this.collection) this.collection.reset();
+    if (this.nav) this.nav.reset();
+    if (this.review) this.review.reset();
+    if (this.composer) this.composer.reset();
+    if (this.ops) this.ops.reset();
+    if (this.gitBranches) this.gitBranches.reset();
+    if (this.commits) this.commits.reset();
+    this.top = this.cwd;
+    this.branch = '';
+    this.status = '';
+    this.layout = 'unified';
+    this.done = false;
+    this.exitCode = 0;
+    this.mode = 'review';
+    this.todoItem = makeTodoItem();
+    this.progressFrame = 0;
+    this.emptyReview = false;
+    this.loadError = null;
+    this.uiOpen = false;
+    this.finishReadLoop = null;
+    if (this.lifecycle) this.lifecycle.stopWatch();
+    if (this.lifecycle) this.lifecycle.clearNpmExtras();
+    if (this.term) this.term.resetCache();
+    if (this.loader) this.loader.reset();
+    if (this.updater) this.updater.reset();
+    if (this.progress) this.progress.clear();
   }
 
-  applyTemplate() {
-    if (this.composeKind !== 'feedback') return;
-    const index = this.templateFocus ? this.templateIndex : 0;
-    this.selectTemplate(index);
+  ensureRepo() {
+    if (!this.repo.toplevel) return;
+    this.top = this.repo.toplevel(this.cwd);
   }
 
-  selectTemplate(index) {
-    const shown = this.shownTemplates();
-    if (!shown.length) return;
-    this.focusTemplate(index, true);
-    this.saveCompose();
+  load() {
+    this.lifecycle.load();
   }
 
-  composeView() {
-    if (this.mode !== 'compose' || !this.editor) return null;
-    const noteKinds = ['feedback', 'commit', 'branch'];
-    if (!noteKinds.includes(this.composeKind)) return null;
-    const kind = this.composeKind;
-    const text = this.editor.text;
-    const cursor = this.editor.cursor;
-    return { kind, text, cursor };
+  loadReady() {
+    return this.lifecycle.loadReady();
   }
 
-  todoEditView() {
-    if (this.mode !== 'compose' || this.composeKind !== 'todo') return null;
-    if (!this.editor) return null;
-    return { cursor: this.editor.cursor };
+  openLoad() {
+    return this.lifecycle.openLoad();
   }
 
-  liveCodeText() {
-    const item = this.current();
-    if (!canEditCode(item)) return null;
-    if (this.mode === 'compose' && this.composeKind === 'code' && this.editor) {
-      return this.editor.text;
-    }
-    if (!this.notes) return null;
-    const note = this.notes.code.get(itemFeedKey(item));
-    if (!note) return null;
-    return note.text;
+  refreshFromRepo(options) {
+    return this.lifecycle.refreshFromRepo(options);
   }
 
-  codeOverlayView() {
-    const text = this.liveCodeText();
-    if (text === null) return null;
-    const editing = this.mode === 'compose' && this.composeKind === 'code';
-    const cursor = editing && this.editor ? this.editor.cursor : null;
-    return { text, keepEmpty: editing, cursor };
+  reloadAfterChange(afterLoad) {
+    this.lifecycle.reloadAfterChange(afterLoad);
   }
 
-  composeTab() {
-    if (this.composeKind === 'code') {
-      this.editor.insert('\t');
-      return;
-    }
-    this.applyTemplate();
+  applyLoaded(loaded) {
+    return this.lifecycle.applyLoaded(loaded);
   }
 
-  listTodos() {
-    if (!this.notes) return [];
-    return this.notes.todos;
+  paint() {
+    if (!this.uiOpen) return;
+    this.draw();
   }
 
-  todoTexts() {
-    if (!this.todoOpen) return [];
-    const texts = [];
-    const editingTodo = this.mode === 'compose' && this.composeKind === 'todo';
-    const editingId = editingTodo ? this.composeTodoId : null;
-    for (const todo of this.listTodos()) {
-      const live = editingId === todo.id && this.editor;
-      const text = live ? this.editor.text : todo.text;
-      texts.push(checkLabel(text, todo.done));
+  draw() {
+    if (this.term.disposed) return;
+    const size = this.getSize();
+    const frame = renderFrame(this.view(), {
+      width: size.width,
+      height: size.height,
+      color: this.color,
+    });
+    if (
+      this.pane === 'files' ||
+      this.pane === 'branches' ||
+      this.pane === 'commits'
+    ) {
+      this.nav.listScroll = frame.listScroll;
     }
-    const draft = this.isDraftCompose() && this.editor ? this.editor.text : '';
-    texts.push(checkLabel(draft, false));
-    return texts;
-  }
-
-  focusedTodo() {
-    if (!this.todoOpen) return null;
-    const todos = this.listTodos();
-    return todos[this.clampedTodoFocus()] ?? null;
+    const composing = this.mode === 'compose';
+    const cursor = composing && this.blinkOn ? frame.cursor : null;
+    this.term.paint(frame, size, cursor);
   }
 
-  clampedTodoFocus() {
-    const last = Math.max(0, this.todoRowCount() - 1);
-    if (this.todoFocus < 0) return 0;
-    if (this.todoFocus > last) return last;
-    return this.todoFocus;
+  view() {
+    return this.viewer.view();
   }
 
-  todoRowCount() {
-    if (!this.todoOpen) return 0;
-    return this.listTodos().length + 1;
+  fileList() {
+    return this.viewer.fileList();
   }
 
-  moveTodoFocus(delta) {
-    if (!this.todoOpen) return;
-    const n = this.todoRowCount();
-    if (!n) return;
-    const next = this.clampedTodoFocus() + delta;
-    if (next < 0) this.todoFocus = 0;
-    else if (next >= n) this.todoFocus = n - 1;
-    else this.todoFocus = next;
+  counts() {
+    return this.viewer.counts();
   }
 
-  idleNoteText() {
-    if (!this.notes) return '';
-    if (this.mode === 'compose') return '';
-    const item = this.current();
-    if (!item || isTodoItem(item)) return '';
-    const note = this.notes.feedback.get(itemFeedKey(item));
-    if (!note || !note.text.trim()) return '';
-    return checkLabel(note.text, note.done);
+  viewStatus() {
+    return this.viewer.viewStatus();
   }
 
-  flushReview(force) {
-    if (!this.notes) return false;
-    try {
-      const writeFileSync = this.writeFileSync;
-      const mkdirSync = this.mkdirSync;
-      const io = { writeFileSync, mkdirSync, force: force === true };
-      return flushReview(this.notes, io);
-    } catch (error) {
-      this.status = error.message;
-      return false;
-    }
+  current() {
+    return this.nav.current(this.items, this.todoItem);
   }
 
-  saveCompose(options) {
-    const opts = options ?? {};
-    if (this.composeKind === 'commit') {
-      this.finishGitCommit();
-      return;
-    }
-    if (this.composeKind === 'branch') {
-      this.finishCreateBranch();
-      return;
-    }
-    const editNext = opts.editNext === true;
-    this.commitCompose();
-    if (this.composeKind === 'feedback') {
-      const next = this.editor ? this.editor.text : '';
-      rememberTemplate(this.notes, this.composeBaseline, next);
-    }
-    this.flushReview();
-    this.closeCompose();
-    this.status = 'saved';
-    if (editNext) this.editNextTodo();
+  fileCursorEntry() {
+    return this.changeActions.fileCursorEntry();
   }
 
-  autosave() {
-    const text = this.editor ? this.editor.text : '';
-    const editingCode = this.mode === 'compose' && this.composeKind === 'code';
-    if (this.mode === 'compose' && (editingCode || text.trim())) {
-      this.commitCompose();
-    }
-    if (this.notes && this.notes.dirty) this.flushReview();
+  clampIndex() {
+    this.filesPane.clampIndex();
   }
 
-  moveComposeLine(delta) {
-    const size = this.lastSize ?? this.getSize();
-    if (this.composeKind === 'todo') {
-      this.moveTodoCompose(delta);
-      return;
-    }
-    if (this.composeKind === 'code') {
-      const inner = codeInnerWidth(size.width, this.layout);
-      this.editor.moveLine(delta, inner);
-      return;
-    }
-    const width = noteInnerWidth(size.width);
-    const shown = this.shownTemplates();
-    if (shown.length && this.composeKind === 'feedback') {
-      if (this.templateFocus) {
-        const next = this.templateIndex + delta;
-        if (next < 0 || next >= shown.length) {
-          this.templateFocus = false;
-          return;
-        }
-        this.focusTemplate(next, false);
-        return;
-      }
-      const pos = cursorInWrap(this.editor.text, this.editor.cursor, width);
-      const last = wrapDoc(this.editor.text, width).length - 1;
-      if (delta < 0 && pos.row === 0) {
-        this.focusTemplate(shown.length - 1, false);
-        return;
-      }
-      if (delta > 0 && pos.row === last) {
-        this.focusTemplate(0, false);
-        return;
-      }
-    }
-    this.editor.moveLine(delta, width);
+  syncReviewPath() {
+    this.filesPane.syncReviewPath();
   }
 
-  resetBlink() {
-    this.blinkOn = true;
-    if (this.blinkTimer === null) return;
-    this.clearInterval(this.blinkTimer);
-    this.blinkTimer = this.setInterval(() => this.tickBlink(), CURSOR_BLINK_MS);
+  syncFileCursor() {
+    this.filesPane.syncFileCursor();
   }
 
-  tickBlink() {
-    if (this.mode !== 'compose') return;
-    this.blinkOn = !this.blinkOn;
-    this.draw();
+  showFiles() {
+    this.filesPane.showFiles();
   }
 
-  handleComposeKey(key) {
-    if (key === 'ctrl-c') {
-      this.onQuit();
-      return;
-    }
-    if (key === 'enter') {
-      if (this.templateFocus && this.composeKind === 'feedback') {
-        this.selectTemplate(this.templateIndex);
-        return;
-      }
-      if (this.composeKind === 'code') {
-        this.editor.insert('\n');
-        this.resetBlink();
-        return;
-      }
-      if (this.composeKind === 'todo') {
-        this.saveCompose({ editNext: true });
-        return;
-      }
-      this.saveCompose();
-      return;
-    }
-    if (key === 'escape' || key === 'ctrl-s') {
-      const cancel = ['commit', 'branch'];
-      if (cancel.includes(this.composeKind) && key === 'escape') {
-        this.closeCompose();
-        this.status = '';
-        return;
-      }
-      this.saveCompose();
-      return;
-    }
-    const special = COMPOSE_SPECIAL[key];
-    if (special) {
-      special(this);
-      if (COMPOSE_EDITS.includes(key)) this.clearTemplatePick();
-      this.resetBlink();
-      return;
-    }
-    if (!key.length) return;
-    if (key.charCodeAt(0) >= 32) {
-      this.clearTemplatePick();
-      this.editor.insert(key);
-      this.resetBlink();
-    }
+  dispatch(action) {
+    this.dispatcher.dispatch(action);
   }
 
-  showFiles() {
-    this.pane = 'files';
-    this.clearSelection();
-    this.followReviewPath();
-    this.todoOpen = false;
+  handleEvent(event) {
+    this.input.handleEvent(event);
   }
 
-  onEscape() {
-    if (this.pane === 'branches') {
-      this.showFiles();
-      return;
+  pushInput(text) {
+    const decoded = decodeChunk(text, this.term.carry);
+    this.term.carry = decoded.carry;
+    for (const event of decoded.events) {
+      this.handleEvent(event);
+      if (this.done) return;
     }
-    if (this.pane === 'files') {
-      this.onQuit();
-      return;
+    if (this.term.carry === '\x1b') {
+      this.term.carry = '';
+      this.handleEvent({ type: 'key', key: 'escape' });
     }
-    this.showFiles();
   }
 
-  onFiles() {
-    if (this.pane === 'files') {
-      if (!this.reviewPath) return;
-      this.pane = 'diff';
-      this.clearSelection();
-      if (this.reviewPath === TODO_FILE) this.openTodoPage();
-      return;
-    }
-    this.showFiles();
+  initReview() {
+    this.review.init(this.top, this.now(), {
+      forceNew: this.forceNewReview,
+    });
   }
 
-  onOpenFile() {
-    if (this.pane === 'branches') return void this.onCheckoutBranch();
-    if (this.pane !== 'files') {
-      if (this.todoOpen) this.editFocusedTodo();
-      return;
-    }
-    const files = this.fileList();
-    const entry = files[this.fileCursor];
-    if (!entry) return;
-    if (isTodosEntry(entry)) {
-      this.openTodoPage();
-      this.status = '';
-      return;
+  flushReview(force) {
+    const result = this.review.flush(force === true);
+    if (!result.ok) {
+      this.status = result.error.message;
+      return false;
     }
-    this.todoOpen = false;
-    this.index = entry.openIndex ?? entry.firstIndex;
-    this.pane = 'diff';
-    this.scroll = 0;
-    this.status = '';
-    this.clearSelection();
-    this.syncReviewPath();
+    return result.wrote;
   }
 
-  onFileMove(delta) {
-    const files = this.fileList();
-    if (!files.length) {
-      this.status = 'nothing to review';
-      return;
-    }
-    const next = Math.min(
-      files.length - 1,
-      Math.max(0, this.fileCursor + delta),
-    );
-    if (next === this.fileCursor) return;
-    this.fileCursor = next;
-    const entry = files[next];
-    if (isTodosEntry(entry)) {
-      this.reviewPath = TODO_FILE;
-    } else {
-      this.reviewPath = entry.path;
-      this.index = entry.firstIndex;
-    }
-    this.status = '';
+  runComposeCommand(result) {
+    if (!result) return;
+    if (result.kind === 'commit') this.commits.finishGitCommit();
+    if (result.kind === 'branch') this.gitBranches.finishCreateBranch();
   }
 
-  scrollStep(fraction) {
-    const bodyH = this.lastFrame?.bodyH;
-    const size = this.lastSize ?? this.getSize();
-    const fallback = Math.max(1, (size.height ?? 24) - 4);
-    const height = Math.max(1, bodyH ?? fallback);
-    const n = Math.max(1, Math.floor(height * Math.abs(fraction)));
-    if (fraction < 0) return -n;
-    return n;
+  selectTemplate(index) {
+    this.runComposeCommand(this.composer.selectTemplate(index));
   }
 
-  onScroll(delta) {
-    if (this.pane === 'files') {
-      this.onFileMove(delta);
-      return;
-    }
-    if (this.pane === 'branches') {
-      this.onBranchMove(delta);
-      return;
-    }
-    if (this.todoOpen && this.todoRowCount() > 1) {
-      this.moveTodoFocus(delta);
-      return;
-    }
-    this.scroll = Math.max(0, this.scroll + delta);
-    this.clearSelection();
+  idleNoteText() {
+    return this.composer.idleNoteText();
   }
 
-  onLayout() {
-    const i = LAYOUTS.indexOf(this.layout);
-    const next = (i < 0 ? 0 : i + 1) % LAYOUTS.length;
-    this.layout = LAYOUTS[next];
-    this.status = this.layout === 'side' ? 'side-by-side' : this.layout;
-    this.scroll = 0;
-    this.clearSelection();
+  shownTemplates() {
+    return this.composer.shownTemplates();
   }
 
-  mouseCell(event) {
-    const size = this.lastSize ?? this.getSize();
-    const x = Math.min(Math.max(1, event.x), size.width);
-    const y = Math.min(Math.max(1, event.y), size.height);
-    return { x, y };
+  startDraftCompose() {
+    this.composer.startDraftCompose();
   }
 
-  onMousePress(event) {
-    const cell = this.mouseCell(event);
-    this.mouseAnchor = cell;
-    this.pendingClick = null;
-    this.selection = null;
-    if (this.lastFrame && cell.y === this.lastFrame.height) {
-      this.pendingClick = hitAction(this.lastFrame.buttons, cell.x - 1);
-    }
+  tickBlink() {
+    this.composer.tickBlink();
   }
 
-  onMouseDrag(event) {
-    if (!this.mouseAnchor) return;
-    this.pendingClick = null;
-    this.selection = {
-      start: this.mouseAnchor,
-      end: this.mouseCell(event),
-    };
+  autosave() {
+    this.composer.autosave();
   }
 
-  clickButton(cell, clickId) {
-    if (!clickId || !this.lastFrame || isRange(this.selection)) return false;
-    const id = hitAction(this.lastFrame.buttons, cell.x - 1);
-    if (id === clickId && cell.y === this.lastFrame.height) {
-      this.dispatch(id);
+  onQuit() {
+    if (this.mode === 'compose') {
+      this.composer.commitCompose();
+      this.composer.closeCompose();
     }
-    this.selection = null;
-    return true;
-  }
-
-  clickHit(hits, cell, onHit) {
-    if (!hits || isRange(this.selection)) return false;
-    const x = cell.x - 1;
-    const hit = hits.find((row) => {
-      if (row.y !== cell.y) return false;
-      if (row.x0 === undefined) return true;
-      return x >= row.x0 && x < row.x1;
-    });
-    if (!hit) return false;
-    onHit(hit);
-    this.selection = null;
-    return true;
+    if (hasNotes(this.notes)) {
+      this.mode = 'confirmQuit';
+      this.status = '';
+      return;
+    }
+    this.done = true;
+    this.exitCode = 0;
   }
 
-  copySelection() {
-    if (!isRange(this.selection) || !this.lastFrame) return;
-    const text = extractText(this.lastFrame.rows, this.selection);
-    if (!text) return;
-    const ok = this.copyText(text, this.stdout);
-    this.status = ok ? 'copied' : 'copy failed';
+  finishQuit(status) {
+    const result = this.review.finishQuit(status);
+    if (!result.ok) this.status = result.error.message;
+    this.done = true;
+    this.exitCode = 0;
   }
 
-  onMouseRelease(event) {
-    const cell = this.mouseCell(event);
-    if (this.mouseAnchor) {
-      this.selection = { start: this.mouseAnchor, end: cell };
-    }
-    const clickId = this.pendingClick;
-    this.pendingClick = null;
-    this.mouseAnchor = null;
-    if (this.clickButton(cell, clickId)) return;
-    const frame = this.lastFrame;
-    for (const target of RELEASE_HITS) {
-      if (!target.match(this)) continue;
-      const hits = target.hits(frame);
-      const opened = this.clickHit(hits, cell, (hit) => {
-        target.onHit(this, hit);
-      });
-      if (opened) return;
-    }
-    this.copySelection();
+  cancelQuit() {
+    this.mode = 'review';
+    this.status = '';
   }
 
-  handleEvent(event) {
-    if (event.type === 'key') {
-      const mode = KEY_MODE[this.mode];
-      if (mode) {
-        mode(this, event.key);
-        return;
-      }
-      if (event.key === 'escape') {
-        this.onEscape();
-        return;
-      }
-      if (this.typeIntoTodo(event.key)) return;
-      const action = actionFromKey(event.key, this.pane);
-      if (action) this.dispatch(action);
-      return;
-    }
-    if (event.type !== 'mouse') return;
-    const kind = event.kind;
-    const wheel = kind === 'wheelUp' || kind === 'wheelDown';
-    if (!wheel && event.btn !== 0 && event.btn !== undefined) return;
-    const handler = MOUSE_KIND[kind];
-    if (handler) handler(this, event);
+  startProgress() {
+    this.progress.start('busy');
   }
 
-  pushInput(text) {
-    const decoded = decodeChunk(text, this.carry);
-    this.carry = decoded.carry;
-    for (const event of decoded.events) {
-      this.handleEvent(event);
-      if (this.done) return;
-    }
-    if (this.carry === '\x1b') {
-      this.carry = '';
-      this.handleEvent({ type: 'key', key: 'escape' });
-    }
+  stopProgress() {
+    this.progress.stop('busy');
   }
 
-  enterTerm() {
-    if (this.stdin && this.stdin.setRawMode) this.stdin.setRawMode(true);
-    if (this.stdin) this.stdin.resume();
-    this.stdout.write(ENTER_TERM);
+  tickProgress() {
+    this.progressFrame += 1;
+    this.paint();
   }
 
-  leaveTerm() {
-    this.stdout.write(LEAVE_TERM);
-    if (this.stdin && this.stdin.setRawMode) this.stdin.setRawMode(false);
+  openUpdate() {
+    return this.updater.open();
   }
 
   async startUi() {
     const empty = !this.items.length;
     const notes = this.notes && hasNotes(this.notes);
-    if (this.didLoad && empty && !notes) {
+    const worktree = !this.rev && !this.change;
+    if (this.didLoad && empty && !notes && !worktree) {
       this.emptyReview = true;
       return 0;
     }
     this.uiOpen = true;
-    this.enterTerm();
+    this.term.enter();
     try {
       this.openLoad();
       this.openUpdate();
@@ -2450,8 +709,8 @@ class Session {
       await this.readLoop();
     } finally {
       this.uiOpen = false;
-      this.leaveTerm();
-      if (this.loadAbort) this.loadAbort.abort();
+      this.term.close();
+      this.loader.abort();
       if (this.installPromise) {
         try {
           await this.installPromise;
@@ -2465,25 +724,14 @@ class Session {
 
   readLoop() {
     return new Promise((resolve) => {
-      this.abortController = new AbortController();
-      const { signal } = this.abortController;
       let settled = false;
       const finish = () => {
         if (settled) return;
         settled = true;
-        if (this.saveTimer !== null) {
-          this.clearInterval(this.saveTimer);
-          this.saveTimer = null;
-        }
-        if (this.blinkTimer !== null) {
-          this.clearInterval(this.blinkTimer);
-          this.blinkTimer = null;
-        }
-        if (this.progressTimer !== null) {
-          this.clearInterval(this.progressTimer);
-          this.progressTimer = null;
-        }
-        this.abortController.abort();
+        this.lifecycle.stopWatch();
+        this.term.stopListening();
+        this.progress.clear();
+        this.term.clearTimers();
         this.finishReadLoop = null;
         resolve();
       };
@@ -2500,13 +748,13 @@ class Session {
         }
         this.draw();
       };
-      this.saveTimer = this.setInterval(() => this.autosave(), AUTOSAVE_MS);
-      this.blinkTimer = this.setInterval(
-        () => this.tickBlink(),
-        CURSOR_BLINK_MS,
-      );
-      this.stdin.on('data', (chunk) => onData(chunk), { signal });
-      watchResize(this.stdout, process, () => this.draw(), signal);
+      this.term.startListening({
+        onData,
+        onResize: () => this.draw(),
+      });
+      this.term.startTimer('save', () => this.autosave(), AUTOSAVE_MS);
+      this.term.startTimer('blink', () => this.tickBlink(), CURSOR_BLINK_MS);
+      this.lifecycle.startWatch();
     });
   }
 }