@crouton-kit/crouter 0.3.27 → 0.3.29

package/dist/builtin-views/git-pr/core.mjs

@@ -0,0 +1,673 @@
+// @ts-check
+/**
+ * Git / PR board — the PORTABLE CORE of the crtr `git-pr` view (manifest · init ·
+ * sources · intents). The reference dual-target view: this one core renders in
+ * BOTH targets — the tmux TUI (`crtr view run git-pr`, via `tui.mjs`) and the
+ * React+Tailwind web page (`crtr view serve git-pr`, via `web.jsx`).
+ *
+ * Runs in BOTH Node and the browser, so it imports NOTHING — no `node:*`, no
+ * crtr. The data layer is expressed as transport-agnostic `Source` descriptors:
+ * the core describes WHAT to run (`request()` → a SourceRequest for `git`/`gh`),
+ * the host's Transport runs it (local `execFile` for the TUI, the HTTP bridge
+ * for web), and the pure `parse()` turns bytes → typed data. The porcelain/JSON
+ * parsing (parseStatus / rollupCi / relAge / classifyGh …) is pure string work
+ * that runs anywhere.
+ *
+ * NOTHING throws. Sources return a `Result<T>` (typed `SourceError` on failure);
+ * the `refresh` intent maps a blocking git error to a guided takeover and keeps
+ * the last-known board on a transient failure (graceful partial failure).
+ *
+ * @module git-pr/core
+ */
+
+/**
+ * @typedef {import('../../core/view/contract.js').Source<any, any>} AnySource
+ * @typedef {import('../../core/view/contract.js').SourceError} SourceError
+ * @typedef {import('../../core/view/contract.js').RawResponse} RawResponse
+ * @typedef {import('../../core/view/contract.js').IntentCtx<GitPrState>} Ctx
+ */
+
+/**
+ * One changed file, flattened from `git status --porcelain=v1 -z`.
+ * @typedef {Object} ChangedFile
+ * @property {string} path
+ * @property {string} xy
+ * @property {'staged'|'modified'|'untracked'|'conflict'} cls
+ * @property {number} add
+ * @property {number} del
+ */
+/**
+ * Local git state. `lastCommit` / `upstream` are null on an empty repo / a branch
+ * with no upstream — degraded fields, not errors.
+ * @typedef {Object} GitState
+ * @property {string} branch
+ * @property {boolean} detached
+ * @property {string|null} upstream
+ * @property {number} ahead
+ * @property {number} behind
+ * @property {{sha:string, subject:string, when:string}|null} lastCommit
+ * @property {ChangedFile[]} files
+ * @property {{staged:number, modified:number, untracked:number, conflict:number}} counts
+ */
+/**
+ * One open pull request, flattened from `gh pr list --json …`.
+ * @typedef {Object} Pr
+ * @property {number} number
+ * @property {string} title
+ * @property {string} headRefName
+ * @property {boolean} isDraft
+ * @property {boolean} current
+ * @property {'approved'|'changes'|'review'} review
+ * @property {'pass'|'fail'|'pending'|'none'} ci
+ * @property {string} updatedAt
+ */
+/**
+ * One logical board row (built once per refresh; re-rendered on resize without a
+ * re-fetch). The cursor moves over all of them — label/spacer rows are inert.
+ * @typedef {{kind:'label', text:string}
+ *   | {kind:'file', file:ChangedFile}
+ *   | {kind:'clean'}
+ *   | {kind:'spacer'}
+ *   | {kind:'pr', pr:Pr}
+ *   | {kind:'note', text:string}} BoardRow
+ */
+/**
+ * The view's immutable state (the core owns it; intents replace it via ctx.set).
+ * @typedef {Object} GitPrState
+ * @property {GitState|null} git
+ * @property {SourceError|null} gitErr   Typed git failure; presenters render its `display` VERBATIM.
+ * @property {Pr[]} prs
+ * @property {string|null} prNote
+ * @property {BoardRow[]} board
+ * @property {number} cursor
+ * @property {number} scroll
+ * @property {number} lastFetch
+ */
+
+// ── Result helpers (inlined — the core imports nothing) ───────────────────────
+
+/** @template T @param {T} data @returns {{ok:true, data:T}} */
+function ok(data) {
+  return { ok: true, data };
+}
+/** @param {SourceError} error @returns {{ok:false, error:SourceError}} */
+function fail(error) {
+  return { ok: false, error };
+}
+
+// ── Tiny pure utilities ───────────────────────────────────────────────────────
+
+/** @param {string} s @returns {string} */
+function firstLine(s) {
+  const lines = String(s || '')
+    .split(/\r?\n/)
+    .map((l) => l.trim())
+    .filter(Boolean);
+  return lines.length ? lines[0] : '';
+}
+
+/** @param {string|number} v @returns {number} */
+function toInt(v) {
+  const n = parseInt(String(v), 10);
+  return Number.isFinite(n) ? n : 0;
+}
+
+/** @param {number} n @param {string} w @returns {string} */
+export function plural(n, w) {
+  return `${n} ${w}${n === 1 ? '' : 's'}`;
+}
+
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+
+/**
+ * Relative-age ladder (design §5): `now` (<60s), `{m}m` (<60m), `{h}h` (<24h),
+ * `{d}d` (<7d), else `Mon D` (`Mar 4`), prior-year `Mon ʼYY`. Max ~5 cols.
+ * Shared by the TUI render + the text dump (both import it from here).
+ * @param {string} iso @param {number} now @returns {string}
+ */
+export function relAge(iso, now) {
+  const t = Date.parse(iso);
+  if (Number.isNaN(t)) return '';
+  const s = Math.max(0, Math.floor((now - t) / 1000));
+  if (s < 60) return 'now';
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h`;
+  const d = Math.floor(h / 24);
+  if (d < 7) return `${d}d`;
+  const date = new Date(t);
+  const mon = MONTHS[date.getMonth()] || '?';
+  if (date.getFullYear() === new Date(now).getFullYear()) return `${mon} ${date.getDate()}`;
+  return `${mon} ʼ${String(date.getFullYear()).slice(-2)}`;
+}
+
+// ── git: status / churn parsing ──────────────────────────────────
+
+/**
+ * Classify a porcelain XY pair into the file's primary class.
+ * @param {string} x @param {string} y
+ * @returns {'staged'|'modified'|'untracked'|'conflict'}
+ */
+function classify(x, y) {
+  if (x === 'U' || y === 'U' || (x === 'A' && y === 'A') || (x === 'D' && y === 'D')) return 'conflict';
+  if (x === '?' || y === '?') return 'untracked';
+  if (y !== ' ' && y !== '') return 'modified';
+  if (x !== ' ' && x !== '') return 'staged';
+  return 'modified';
+}
+
+/**
+ * Parse `git status --porcelain=v1 -z -uall` into changed files + column tallies.
+ * @param {string} stdout
+ * @returns {{files: ChangedFile[], counts: GitState['counts']}}
+ */
+function parseStatus(stdout) {
+  const parts = String(stdout || '').split('\0');
+  /** @type {ChangedFile[]} */
+  const files = [];
+  const counts = { staged: 0, modified: 0, untracked: 0, conflict: 0 };
+  for (let i = 0; i < parts.length; i++) {
+    const entry = parts[i];
+    if (!entry || entry.length < 3) continue;
+    const x = entry[0];
+    const y = entry[1];
+    const path = entry.slice(3);
+    if (x === 'R' || x === 'C' || y === 'R' || y === 'C') i++;
+    const cls = classify(x, y);
+    if (cls === 'conflict') counts.conflict++;
+    else if (cls === 'untracked') counts.untracked++;
+    else {
+      if (x !== ' ' && x !== '?' && x !== '') counts.staged++;
+      if (y !== ' ' && y !== '?' && y !== '') counts.modified++;
+    }
+    files.push({ path, xy: `${x}${y}`, cls, add: 0, del: 0 });
+  }
+  return { files, counts };
+}
+
+/**
+ * Parse `git diff [--cached] --numstat` into a path→churn map. Binary files
+ * (`-\t-`) and renames (`old => new`) are skipped — churn is best-effort.
+ * @param {string} stdout
+ * @returns {Array<{path:string, add:number, del:number}>}
+ */
+function parseNumstat(stdout) {
+  /** @type {Array<{path:string, add:number, del:number}>} */
+  const out = [];
+  for (const line of String(stdout || '').split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    const m = line.split('\t');
+    if (m.length < 3) continue;
+    const add = m[0];
+    const del = m[1];
+    const path = m.slice(2).join('\t');
+    if (add === '-' || del === '-' || path.includes(' => ')) continue;
+    out.push({ path, add: toInt(add), del: toInt(del) });
+  }
+  return out;
+}
+
+const CLASS_RANK = { conflict: 0, staged: 1, modified: 2, untracked: 3 };
+
+// ── gh: rollups + classification ────────────────────────────────
+
+const CI_BAD = new Set(['FAILURE', 'ERROR', 'CANCELLED', 'TIMED_OUT', 'ACTION_REQUIRED', 'STARTUP_FAILURE']);
+const CI_GOOD = new Set(['SUCCESS', 'NEUTRAL', 'SKIPPED']);
+
+/** @param {any[]|undefined} items @returns {'pass'|'fail'|'pending'|'none'} */
+function rollupCi(items) {
+  if (!Array.isArray(items) || items.length === 0) return 'none';
+  let pending = false;
+  for (const it of items) {
+    const concl = String((it && it.conclusion) || '').toUpperCase();
+    const state = String((it && it.state) || '').toUpperCase();
+    const status = String((it && it.status) || '').toUpperCase();
+    if (CI_BAD.has(concl) || CI_BAD.has(state)) return 'fail';
+    if (status && status !== 'COMPLETED') pending = true;
+    else if (state && !CI_GOOD.has(state) && !CI_BAD.has(state)) pending = true;
+    else if (!concl && !state && !status) pending = true;
+  }
+  return pending ? 'pending' : 'pass';
+}
+
+/** @param {string} d @returns {'approved'|'changes'|'review'} */
+function normReview(d) {
+  const s = String(d || '').toUpperCase();
+  if (s === 'APPROVED') return 'approved';
+  if (s === 'CHANGES_REQUESTED') return 'changes';
+  return 'review';
+}
+
+// ── Typed SourceError displays (the `display`/`kind` split; presenters render
+//    `display` verbatim and never branch on `kind`) ────────────────────────────
+
+/** @type {SourceError} */
+const GIT_MISSING = {
+  kind: 'git-missing',
+  display: {
+    headline: 'git not found',
+    explanation: 'crtr could not find the git binary on PATH.',
+    nextStep: 'Install git, then press g.',
+    level: 'error',
+    blocking: true,
+  },
+};
+/** @type {SourceError} */
+const NOT_A_REPO = {
+  kind: 'not-a-repo',
+  display: {
+    headline: 'Not a git repository',
+    explanation: 'This view monitors a git repo, and the current directory is not one.',
+    nextStep: 'cd into a repository (or run `git init`), then press g.',
+    level: 'action',
+    blocking: true,
+  },
+};
+/** @param {string} msg @returns {SourceError} */
+function gitFailed(msg) {
+  return {
+    kind: 'git-failed',
+    display: {
+      headline: 'Git unavailable',
+      explanation: msg || 'A git command failed.',
+      nextStep: 'Press g to retry.',
+      level: 'error',
+      blocking: false,
+    },
+  };
+}
+/** @param {string} kind @param {string} headline @returns {SourceError} */
+function ghError(kind, headline) {
+  return { kind, display: { headline, explanation: '', nextStep: '', level: 'info', blocking: false } };
+}
+/**
+ * Classify a failed `gh` invocation into a guided PR-section note (auth first,
+ * then network, then a missing remote, else generic).
+ * @param {string} stderr @returns {SourceError}
+ */
+function classifyGh(stderr) {
+  const s = String(stderr || '').toLowerCase();
+  if (/auth|logged in|gh auth login|authentication|not logged/.test(s)) {
+    return ghError('gh-unauthed', 'gh is not authenticated — run `gh auth login`.');
+  }
+  if (/could not resolve host|dial tcp|network is unreachable|no such host|timeout|temporary failure|connection refused/.test(s)) {
+    return ghError('gh-network', 'Cannot reach GitHub (offline?).');
+  }
+  if (/could not resolve to a repository|no git remote|none of the git remotes|no default remote|not a github|head branch could not/.test(s)) {
+    return ghError('gh-no-remote', 'No GitHub remote for this repository.');
+  }
+  return ghError('gh-failed', firstLine(stderr) || 'gh command failed.');
+}
+
+// ── Sources (reads): a request descriptor + a pure parse. The host's transport
+//    runs the request (local execFile for TUI, the HTTP bridge for web). ───────
+
+/**
+ * PRIMARY git instrument — working-tree status. Its parse owns the three hard
+ * git states (missing binary / not-a-repo / a failing git command); empty-repo
+ * and no-upstream degrade to null fields on the secondary reads, not errors.
+ * @type {import('../../core/view/contract.js').Source<{files:ChangedFile[], counts:GitState['counts']}>}
+ */
+export const gitStatusSource = {
+  id: 'git-status',
+  request: () => ({ kind: 'exec', bin: 'git', args: ['status', '--porcelain=v1', '-z', '--untracked-files=all'] }),
+  parse: (raw) => {
+    if (!raw.ok) return fail(GIT_MISSING);
+    if (raw.exitCode !== 0) {
+      const s = String(raw.stderr || '').toLowerCase();
+      if (/not a git repository/.test(s)) return fail(NOT_A_REPO);
+      return fail(gitFailed(firstLine(raw.stderr)));
+    }
+    return ok(parseStatus(raw.stdout));
+  },
+};
+
+/** Current branch name ('' ⇒ detached HEAD; resolve via gitHeadSource). */
+export const gitBranchSource = {
+  id: 'git-branch',
+  request: () => ({ kind: 'exec', bin: 'git', args: ['branch', '--show-current'] }),
+  parse: (raw) => ok(raw.ok && raw.exitCode === 0 ? raw.stdout.trim() : ''),
+};
+
+/** Short HEAD sha — used to label a detached HEAD. */
+export const gitHeadSource = {
+  id: 'git-head',
+  request: () => ({ kind: 'exec', bin: 'git', args: ['rev-parse', '--short', 'HEAD'] }),
+  parse: (raw) => ok(raw.ok && raw.exitCode === 0 ? raw.stdout.trim() : ''),
+};
+
+/** Tracking ref (e.g. "origin/main") or null when no upstream is set. */
+export const gitUpstreamSource = {
+  id: 'git-upstream',
+  request: () => ({ kind: 'exec', bin: 'git', args: ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'] }),
+  parse: (raw) => ok(raw.ok && raw.exitCode === 0 ? raw.stdout.trim() : null),
+};
+
+/** Ahead/behind vs upstream (only meaningful when an upstream exists). */
+export const gitAheadBehindSource = {
+  id: 'git-ahead-behind',
+  request: () => ({ kind: 'exec', bin: 'git', args: ['rev-list', '--left-right', '--count', '@{upstream}...HEAD'] }),
+  parse: (raw) => {
+    if (!raw.ok || raw.exitCode !== 0) return ok({ ahead: 0, behind: 0 });
+    const nums = raw.stdout.trim().split(/\s+/);
+    return ok({ behind: toInt(nums[0]), ahead: toInt(nums[1]) });
+  },
+};
+
+/** Last commit (null on an empty repo). */
+export const gitLogSource = {
+  id: 'git-log',
+  request: () => ({ kind: 'exec', bin: 'git', args: ['log', '-1', '--pretty=%h%x1f%s%x1f%cI'] }),
+  parse: (raw) => {
+    if (!raw.ok || raw.exitCode !== 0 || raw.stdout.trim() === '') return ok(null);
+    const [sha, subject, when] = raw.stdout.replace(/\n$/, '').split('\x1f');
+    return ok({ sha: sha || '', subject: subject || '', when: when || '' });
+  },
+};
+
+/** Unstaged churn (best-effort; never fatal). */
+export const gitDiffSource = {
+  id: 'git-diff',
+  request: () => ({ kind: 'exec', bin: 'git', args: ['diff', '--numstat'] }),
+  parse: (raw) => ok(raw.ok && raw.exitCode === 0 ? parseNumstat(raw.stdout) : []),
+};
+
+/** Staged churn (best-effort; never fatal). */
+export const gitDiffCachedSource = {
+  id: 'git-diff-cached',
+  request: () => ({ kind: 'exec', bin: 'git', args: ['diff', '--cached', '--numstat'] }),
+  parse: (raw) => ok(raw.ok && raw.exitCode === 0 ? parseNumstat(raw.stdout) : []),
+};
+
+/**
+ * Open PRs for this repo. BEST-EFFORT: a typed error becomes the PR section's
+ * guided note (the git section is unaffected). `current`/sort-by-current is
+ * applied in `refresh` (parse has no access to the branch).
+ * @type {import('../../core/view/contract.js').Source<Pr[]>}
+ */
+export const prsSource = {
+  id: 'prs',
+  request: () => ({
+    kind: 'exec', bin: 'gh',
+    args: ['pr', 'list', '--state', 'open', '--limit', '30', '--json',
+      'number,title,headRefName,reviewDecision,statusCheckRollup,updatedAt,isDraft'],
+  }),
+  parse: (raw) => {
+    if (!raw.ok) return fail(ghError('gh-missing', 'gh (GitHub CLI) not found — install it to see PRs.'));
+    if (raw.exitCode !== 0) return fail(classifyGh(raw.stderr || raw.stdout));
+    let arr;
+    try {
+      arr = JSON.parse(raw.stdout.trim() || '[]');
+    } catch {
+      return fail(ghError('gh-failed', 'could not parse gh output as JSON.'));
+    }
+    if (!Array.isArray(arr)) arr = [];
+    /** @type {Pr[]} */
+    const prs = arr.map((p) => {
+      const o = p || {};
+      const head = String(o.headRefName || '');
+      return {
+        number: typeof o.number === 'number' ? o.number : toInt(o.number),
+        title: String(o.title || '(untitled)'),
+        headRefName: head,
+        isDraft: !!o.isDraft,
+        current: false,
+        review: normReview(o.reviewDecision),
+        ci: rollupCi(o.statusCheckRollup),
+        updatedAt: String(o.updatedAt || ''),
+      };
+    });
+    return ok(prs);
+  },
+};
+
+// ── Board model + chrome copy (shared by render + dump; pure) ──────────────────
+
+/**
+ * Flatten git + PR state into the ordered board rows. Each section degrades
+ * inline (a clean reward row / a guided gh note / a "no open PRs" note).
+ * @param {GitPrState} state @returns {BoardRow[]}
+ */
+export function buildBoard(state) {
+  /** @type {BoardRow[]} */
+  const rows = [];
+  const g = state.git;
+  rows.push({ kind: 'label', text: 'Working tree' });
+  if (!g || g.files.length === 0) rows.push({ kind: 'clean' });
+  else for (const f of g.files) rows.push({ kind: 'file', file: f });
+
+  rows.push({ kind: 'spacer' });
+  rows.push({ kind: 'label', text: 'Pull requests' });
+  if (state.prNote) rows.push({ kind: 'note', text: state.prNote });
+  else if (state.prs.length === 0) rows.push({ kind: 'note', text: 'No open pull requests.' });
+  else for (const pr of state.prs) rows.push({ kind: 'pr', pr });
+  return rows;
+}
+
+/** Working-tree state as one short phrase, for the subtitle + dump. @param {GitState} g */
+export function treePhrase(g) {
+  const c = g.counts;
+  if (g.files.length === 0) return 'clean';
+  /** @type {string[]} */
+  const parts = [];
+  if (c.conflict) parts.push(`${c.conflict} conflict`);
+  if (c.staged) parts.push(`${c.staged} staged`);
+  if (c.modified) parts.push(`${c.modified} modified`);
+  if (c.untracked) parts.push(`${c.untracked} untracked`);
+  return parts.join(' · ') || plural(g.files.length, 'change');
+}
+
+/** Live title subtitle — branch + tracking delta + tree state. @param {{git:GitState|null}} state */
+function subtitleFor(state) {
+  const g = state.git;
+  if (!g) return null;
+  let s = g.branch;
+  if (g.ahead) s += ` ↑${g.ahead}`;
+  if (g.behind) s += ` ↓${g.behind}`;
+  s += ` · ${treePhrase(g)}`;
+  return s;
+}
+
+/** Footer status (left, transient). @param {{git:GitState|null, prs:Pr[], prNote:string|null}} state */
+function footerSummary(state) {
+  const g = state.git;
+  if (!g) return null;
+  const files = g.files.length === 0 ? 'clean' : plural(g.files.length, 'change');
+  const prs = state.prNote ? 'PRs n/a' : plural(state.prs.length, 'PR');
+  return `${files} · ${prs}`;
+}
+
+/** The one thing that wants a human's eyes → an ACTION banner. @param {{git:GitState|null, prs:Pr[], prNote:string|null}} state */
+function attentionFor(state) {
+  const g = state.git;
+  /** @type {string[]} */
+  const parts = [];
+  if (g && g.counts.conflict) parts.push(`${plural(g.counts.conflict, 'conflict')}`);
+  if (!state.prNote) {
+    const failing = state.prs.filter((p) => p.ci === 'fail').length;
+    const changes = state.prs.filter((p) => p.review === 'changes').length;
+    if (failing) parts.push(`${failing} PR${failing === 1 ? '' : 's'} failing CI`);
+    if (changes) parts.push(`${changes} PR${changes === 1 ? '' : 's'} need changes`);
+  }
+  return parts.length ? `${parts.join(' · ')} — needs attention` : null;
+}
+
+// ── The portable core ──────────────────────────────────────────────────────────
+
+/** @type {import('../../core/view/contract.js').ViewCore<GitPrState>} */
+const core = {
+  manifest: {
+    id: 'git-pr',
+    title: 'Git / PR',
+    description: 'Local git state + GitHub PR/CI status for the repo at this cwd',
+    refreshMs: 5000,
+  },
+
+  /** Cheap + synchronous initial state — NO fetch (the host paints a loading
+   *  frame, then dispatches the first 'refresh'). @returns {GitPrState} */
+  init() {
+    return {
+      git: null,
+      gitErr: null,
+      prs: [],
+      prNote: null,
+      board: [],
+      cursor: 0,
+      scroll: 0,
+      lastFetch: 0,
+    };
+  },
+
+  sources: {
+    gitStatusSource,
+    gitBranchSource,
+    gitHeadSource,
+    gitUpstreamSource,
+    gitAheadBehindSource,
+    gitLogSource,
+    gitDiffSource,
+    gitDiffCachedSource,
+    prsSource,
+  },
+
+  intents: {
+    /**
+     * Read git + PR state, rebuild the board. Runs in the host's single-flight
+     * lane. A BLOCKING git error (no binary / not a repo) drops to a guided
+     * takeover; a transient git-failed KEEPS the last-known board + a banner. PR
+     * failures degrade the PR section only (an inline note).
+     * @param {Ctx} ctx
+     */
+    async refresh(ctx) {
+      ctx.signal.setStatus('Reading git…');
+
+      const st = await ctx.resolve(gitStatusSource);
+      if (!st.ok) {
+        const err = st.error;
+        const hadGit = ctx.state.git != null;
+        // git-failed WITH a last-known board ⇒ keep it (transient). Hard cases
+        // (not-a-repo / git-missing) and a first-load git-failed ⇒ takeover.
+        const keep = !err.display.blocking && hadGit;
+        ctx.set((s) => {
+          /** @type {GitPrState} */
+          const next = { ...s, gitErr: err };
+          if (!keep) {
+            next.git = null;
+            next.prs = [];
+            next.prNote = null;
+            next.board = buildBoard(next);
+          }
+          next.lastFetch = Date.now();
+          return next;
+        });
+        // A takeover owns the whole rect and already names cause + next step —
+        // don't stack a banner under it. A kept board raises the cause instead.
+        if (keep) ctx.signal.setBanner(err.display.explanation, err.display.level);
+        else ctx.signal.clearBanner();
+        ctx.signal.setStatus(null);
+        ctx.signal.setSubtitle(keep ? subtitleFor(ctx.state) : null);
+        return;
+      }
+
+      // Secondary git reads — independent, best-effort, resolved concurrently.
+      const [brR, headR, upR, abR, logR, diffR, diffCR] = await Promise.all([
+        ctx.resolve(gitBranchSource),
+        ctx.resolve(gitHeadSource),
+        ctx.resolve(gitUpstreamSource),
+        ctx.resolve(gitAheadBehindSource),
+        ctx.resolve(gitLogSource),
+        ctx.resolve(gitDiffSource),
+        ctx.resolve(gitDiffCachedSource),
+      ]);
+
+      let branch = brR.ok ? brR.data : '';
+      let detached = false;
+      if (branch === '') {
+        detached = true;
+        branch = headR.ok && headR.data ? `(detached ${headR.data})` : '(no branch)';
+      }
+      const upstream = upR.ok ? upR.data : null;
+      let ahead = 0;
+      let behind = 0;
+      if (upstream && abR.ok) {
+        ahead = abR.data.ahead;
+        behind = abR.data.behind;
+      }
+      const lastCommit = logR.ok ? logR.data : null;
+
+      // Churn (best-effort) → apply to the status files, then problems-first sort.
+      /** @type {Map<string,{add:number,del:number}>} */
+      const churn = new Map();
+      const accChurn = (rows) => {
+        for (const c of rows) {
+          const prev = churn.get(c.path) || { add: 0, del: 0 };
+          prev.add += c.add;
+          prev.del += c.del;
+          churn.set(c.path, prev);
+        }
+      };
+      if (diffR.ok) accChurn(diffR.data);
+      if (diffCR.ok) accChurn(diffCR.data);
+
+      const { files, counts } = st.data;
+      for (const f of files) {
+        const c = churn.get(f.path);
+        if (c) {
+          f.add = c.add;
+          f.del = c.del;
+        }
+      }
+      files.sort((a, b) => {
+        const r = CLASS_RANK[a.cls] - CLASS_RANK[b.cls];
+        return r !== 0 ? r : a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
+      });
+
+      /** @type {GitState} */
+      const git = { branch, detached, upstream, ahead, behind, lastCommit, files, counts };
+
+      // PRs — best-effort. Mark the current-branch PR + sort it first.
+      const p = await ctx.resolve(prsSource);
+      /** @type {Pr[]} */
+      let prs = [];
+      /** @type {string|null} */
+      let prNote = null;
+      if (p.ok) {
+        prs = p.data.map((pr) => ({ ...pr, current: pr.headRefName !== '' && pr.headRefName === branch }));
+        prs.sort((a, b) => {
+          if (a.current !== b.current) return a.current ? -1 : 1;
+          return a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : 0;
+        });
+      } else {
+        prNote = p.error.display.headline;
+      }
+
+      ctx.set((s) => {
+        /** @type {GitPrState} */
+        const next = { ...s, git, gitErr: null, prs, prNote };
+        next.board = buildBoard(next);
+        if (next.cursor >= next.board.length) next.cursor = Math.max(0, next.board.length - 1);
+        next.lastFetch = Date.now();
+        return next;
+      });
+
+      const live = { git, prs, prNote };
+      ctx.signal.setSubtitle(subtitleFor(live));
+      const attn = attentionFor(live);
+      if (attn) ctx.signal.setBanner(attn, 'action');
+      else ctx.signal.clearBanner();
+      ctx.signal.setStatus(footerSummary(live));
+    },
+
+    /** @param {Ctx} ctx */
+    cursorDown: (ctx) => ctx.set((s) => ({ ...s, cursor: s.board.length ? Math.min(s.board.length - 1, s.cursor + 1) : 0 })),
+    /** @param {Ctx} ctx */
+    cursorUp: (ctx) => ctx.set((s) => ({ ...s, cursor: Math.max(0, s.cursor - 1) })),
+    /** @param {Ctx} ctx @param {number} [i] */
+    select: (ctx, i) => ctx.set((s) => ({ ...s, cursor: typeof i === 'number' ? Math.max(0, Math.min(s.board.length - 1, i)) : s.cursor })),
+    /** @param {Ctx} ctx */
+    quit: (ctx) => ctx.signal.quit(),
+  },
+};
+
+export default core;