reslop 0.2.5 → 0.2.6

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased][unreleased]
 
+## [0.2.6][] - 2026-10-02
+
+- Add a live dashboard as the start screen
+- Compact related failure contexts in test runnter logs
+- Save the raw command output beside the reduced log
+- Improve test results rendering
+- Update the dashboard from file system events, without timers
+- Record `reslop t` runs under `.log/.runs/` show progress on the dashboard
+- Implement tasks screen: backlog, issues, bugs, features
+
 ## [0.2.5][] - 2026-09-30
 
 - Remove UI and filesystem polling timers, refresh on events
@@ -153,7 +163,8 @@
 - Feedback and todos that produce a repair plan for an agent
 - Intra-line highlighting in unified, mixed, and side-by-side layouts
 
-[unreleased]: https://github.com/tshemsedinov/reslop/compare/v0.2.5...HEAD
+[unreleased]: https://github.com/tshemsedinov/reslop/compare/v0.2.6...HEAD
+[0.2.6]: https://github.com/tshemsedinov/reslop/compare/v0.2.5...v0.2.6
 [0.2.5]: https://github.com/tshemsedinov/reslop/compare/v0.2.4...v0.2.5
 [0.2.4]: https://github.com/tshemsedinov/reslop/compare/v0.2.3...v0.2.4
 [0.2.3]: https://github.com/tshemsedinov/reslop/compare/v0.2.1...v0.2.3

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Timur Shemsedinov
+Copyright (c) 2026 Timur Shemsedinov and other contributors (see github)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -17,21 +17,19 @@ Open a change, leave findings and a backlog, and prepare a repair plan for the a
 Review → Plan → Repair → Verify
 ```
 
+- Live dashboard: files, diffs, tasks, branches, commits, run, and npm, updated in real time
 - Leave feedback, a project backlog, and in-place code proposals as a repair plan
 - Review uncommitted git diffs, a given commit, a GitHub PR, or a GitLab MR
 - File-scope review mode: not just diffs, with editor mode
 - Stage, unstage, or revert each contiguous block of diff lines
 - Auto-reload local diffs when files change, keeping the current screen
 - Import GitHub PR and GitLab MR review comments into the local plan for AI
-- Commits list: brief and full, view a commit's diff, commit, amend, fixup, reword, drop, pull, and push
-- Branches: checkout, create, rebase, drop, pull, and push
+- Commits list: brief and full, view a commit's diff, commit, amend, apply, edit, fixup, and delete
+- Branches: checkout, create, rebase, delete, pull, and push
 - npm scripts and bins: run, edit, and reorder; double-click to run; clean logs older than 5 days
-- Long lines wrap in the diff view; the editor scrolls horizontally
 - Reduced test and lint output for agents: failures and a short summary, not passing noise
-- Review each npm dependency once across `package.json` and the lockfile
-- Propose unused removals, npm audit fixes, and outdated updates as diffs
-- Code highlighting and intra-line diffs: unified, mixed, and side-by-side
-- Auto-update patch and minor releases; confirm a new major
+- Review, renew, audit and update npm dependencies in `package.json` and the lockfile
+- Auto-update reslop patch and minor releases; confirm a new major
 - Work with git, npm and fetch in background
 
 ## Install
@@ -45,8 +43,8 @@ Requires Node.js `>=18.15.0`.
 
 ## Usage
 
-- `reslop` uncommitted diffs in this repository
-- `reslop path/file` show only that path or file
+- `reslop` live dashboard of this repository; press a block key to open its screen
+- `reslop path/file` show only that path or file (starts on the file list)
 - `reslop 7ac260c` show that commit (read-only)
 - `reslop https://github.com/metarhia/metacom/pull/555` GitHub/GitLab PR/MR
 - `reslop -n` start a new review even if the latest is still editing
@@ -61,10 +59,12 @@ Prefix each program in an npm script with `reslop t --`. Keep `&&` between those
 "test": "reslop t -- npm run -s lint && reslop t -- node --test"
 ```
 
-The report is Markdown: failures, diagnostics, and a short summary. Passing results are omitted and similar problems are grouped. The same text is saved under `.log/`. Set `RESLOP_OUTPUT=raw` to pass the command through unchanged. The review screen runs scripts in raw mode and applies its own filter once.
+The report is Markdown: failures, diagnostics, and a short summary. Passing results are omitted and similar problems are grouped. The reduced report and the raw output are both saved under `.log/`. The report names the raw file for an agent to read when a detail is missing. Set `RESLOP_OUTPUT=raw` to pass the command through unchanged. The review screen runs scripts in raw mode and applies its own filter once.
 
 Run the full check with `npm t`. Run one or more test files with `reslop t -- node --test <files>`. New reviews include those two commands in the agent instructions.
 
+`reslop t` records each run in `.log/.runs/` so that the dashboard can show commands started by an agent in another terminal.
+
 Reviews go in `.review/YYYY-MM-DD-NN.md` with frontmatter `status`:
 
 - `editing`: still writing the review in reslop
@@ -87,5 +87,5 @@ Reviews go in `.review/YYYY-MM-DD-NN.md` with frontmatter `status`:
 
 ## License
 
-Copyright (c) 2026 Timur Shemsedinov.
+Copyright (c) 2026 Timur Shemsedinov and other contributors (see github).
 This is [MIT](./LICENSE) licensed software.

package/bin/reslop.js

@@ -16,12 +16,7 @@ const fail = (reason) => {
   process.exit(1);
 };
 
-process.on('uncaughtException', (error) => fail(error));
-process.on('unhandledRejection', (reason) => fail(reason));
+process.on('uncaughtException', fail);
+process.on('unhandledRejection', fail);
 
-run(process).then(
-  (code) => {
-    process.exit(code);
-  },
-  (error) => fail(error),
-);
+run(process).then((code) => process.exit(code), fail);

package/lib/ansi.js

@@ -84,6 +84,14 @@ const DARK_UI = {
   stagedAddLineBg: [0x26, 0x26, 0x2e],
   stagedAddCharFg: [0xff, 0xff, 0xff],
   stagedAddCharBg: [0x4e, 0x4e, 0x58],
+  dashBg: [0x00, 0x00, 0x00],
+  dashTileBg: [0x26, 0x26, 0x2a],
+  dashRowBg: [0x1c, 0x1c, 0x1f],
+  dashHeadBg: [0x70, 0x70, 0x7c],
+  dashHeadMuted: [0xf2, 0xf2, 0xfa],
+  dashDelFg: [0xff, 0xd2, 0xd2],
+  dashTrendFg: [0x4a, 0x62, 0x70],
+  dashKeyFg: [0xff, 0xff, 0xff],
 };
 
 const DARK_CODE = {
@@ -176,6 +184,14 @@ const LIGHT_UI = {
   stagedAddLineBg: [0xea, 0xec, 0xef],
   stagedAddCharFg: [0x0f, 0x14, 0x19],
   stagedAddCharBg: [0xcc, 0xd1, 0xd7],
+  dashBg: [0xff, 0xff, 0xff],
+  dashTileBg: [0xe4, 0xe7, 0xeb],
+  dashRowBg: [0xd9, 0xdc, 0xe1],
+  dashHeadBg: [0xe8, 0xeb, 0xef],
+  dashHeadMuted: [0x3e, 0x46, 0x52],
+  dashDelFg: [0xd0, 0x3a, 0x44],
+  dashTrendFg: [0x8a, 0x98, 0xa6],
+  dashKeyFg: [0x00, 0x00, 0x00],
 };
 
 const LIGHT_CODE = {
@@ -233,26 +249,16 @@ const THEME_NAMES = Object.keys(PALETTES);
 const applyColors = (into, from) => {
   for (const key of Object.keys(from)) {
     const src = from[key];
-    let dst = into[key];
-    if (!dst) {
-      dst = [0, 0, 0];
-      into[key] = dst;
-    }
+    const dst = into[key];
     dst[0] = src[0];
     dst[1] = src[1];
     dst[2] = src[2];
   }
-  return into;
-};
-
-const cloneColors = (colors) => {
-  const into = Array.isArray(colors) ? [] : {};
-  return applyColors(into, colors);
 };
 
-const THEME = cloneColors(DARK_UI);
-const CODE_FG = cloneColors(DARK_CODE);
-const LOG_COL_FG = cloneColors(DARK_LOG_COLS);
+const THEME = structuredClone(DARK_UI);
+const CODE_FG = structuredClone(DARK_CODE);
+const LOG_COL_FG = structuredClone(DARK_LOG_COLS);
 let currentTheme = 'dark';
 
 const setTheme = (name) => {
@@ -339,22 +345,27 @@ const visibleWidth = (text) => {
   return width;
 };
 
-const truncateVisible = (text, width) => {
+const truncateVisible = (text, width, mark = '') => {
   if (width <= 0) return '';
-  if (visibleWidth(text) <= width) return text;
   const plain = stripAnsi(text);
+  if (visibleWidth(plain) <= width) return text;
+  const markW = mark ? visibleWidth(mark) : 0;
+  const fits = markW > 0 && markW <= width;
+  const limit = fits ? width - markW : width;
   const parts = graphemes(plain);
   let used = 0;
   let out = '';
   for (const ch of parts) {
     const w = graphemeWidth(ch, used);
-    if (used + w > width) break;
+    if (used + w > limit) break;
     out += ch;
     used += w;
   }
-  return out;
+  return fits ? `${out}${mark}` : out;
 };
 
+const trimVisible = (text, width) => truncateVisible(text, width, '…');
+
 const csiLength = (text, index) => {
   if (text[index] !== ESC || text[index + 1] !== '[') return 0;
   let at = index + 2;
@@ -459,7 +470,7 @@ const foregroundOn = (text, bgRgb) => {
     const kept = keepFgParams(sgrParams(seq));
     const reset = kept.includes(0);
     const rest = kept.filter((code) => code !== 0);
-    if (reset) out += `${ESC}[0m`;
+    if (reset) out += RESET;
     out += ground;
     if (rest.length) out += `${ESC}[${rest.join(';')}m`;
   }
@@ -487,6 +498,8 @@ module.exports = {
   graphemeWidth,
   visibleWidth,
   truncateVisible,
+  trimVisible,
+  firstGrapheme,
   clipAnsi,
   foregroundOn,
 };

package/lib/capabilities.js

@@ -50,12 +50,14 @@ const BRANCH_METHODS = [
   'pushAsync',
 ];
 
+const VIEW_CAPS = { read: true, changes: false, branches: false, review: true };
+
 const SOURCE_CAPS = {
   local: { read: true, changes: true, branches: true, review: true },
-  commit: { read: true, changes: false, branches: false, review: true },
-  pr: { read: true, changes: false, branches: false, review: true },
-  mr: { read: true, changes: false, branches: false, review: true },
-  readonly: { read: true, changes: false, branches: false, review: true },
+  commit: VIEW_CAPS,
+  pr: VIEW_CAPS,
+  mr: VIEW_CAPS,
+  readonly: VIEW_CAPS,
 };
 
 const withReadOnly = (caps, readOnly) => {
@@ -88,12 +90,10 @@ const sessionCapabilities = (options) => {
   if (options.capabilities) return withReadOnly(options.capabilities, readOnly);
   if (options.rev) return capabilitiesFor('commit', { readOnly });
   const source = options.change && options.change.source;
-  if (source && SOURCE_CAPS[source]) {
-    return capabilitiesFor(source, { readOnly });
-  }
+  if (SOURCE_CAPS[source]) return capabilitiesFor(source, { readOnly });
   const repoCaps = options.repo && options.repo.capabilities;
   if (repoCaps) return withReadOnly(repoCaps, readOnly);
-  return capabilitiesFor(readOnly ? 'readonly' : 'local');
+  return capabilitiesFor('local', { readOnly });
 };
 
 module.exports = {

package/lib/cli.js

@@ -44,12 +44,8 @@ const REMOTE_CHANGE = {
   },
 };
 
-const errorMessage = (reason) => {
-  if (reason instanceof Error) return reason.message;
-  if (reason === null || reason === undefined) return '';
-  if (typeof reason === 'string') return reason;
-  return `${reason}`;
-};
+const errorMessage = (reason) =>
+  reason instanceof Error ? reason.message : `${reason ?? ''}`;
 
 const fail = (stderr, reason) => {
   stderr.write(`reslop: ${errorMessage(reason)}\n`);
@@ -62,81 +58,44 @@ const parseArgv = (argv) => {
   let readOnly = false;
   let theme = 'dark';
   for (const arg of argv) {
-    if (arg === '-n') {
-      newReview = true;
-      continue;
-    }
-    if (arg === '-r') {
-      readOnly = true;
-      continue;
-    }
-    if (arg === '-light') {
-      theme = 'light';
-      continue;
-    }
-    if (arg.startsWith('-')) {
-      throw new Error(`unknown option ${arg}`);
-    }
-    paths.push(arg);
+    if (arg === '-n') newReview = true;
+    else if (arg === '-r') readOnly = true;
+    else if (arg === '-light') theme = 'light';
+    else if (arg.startsWith('-')) throw new Error(`unknown option ${arg}`);
+    else paths.push(arg);
   }
   return { paths, newReview, readOnly, theme };
 };
 
-const looksLikeRev = (spec) => {
-  if (!spec) return false;
-  if (HEX_REV.test(spec)) return true;
-  if (HEAD_REV.test(spec)) return true;
-  return RANGE_REV.test(spec);
-};
+const looksLikeRev = (spec) =>
+  HEX_REV.test(spec) || HEAD_REV.test(spec) || RANGE_REV.test(spec);
 
 const resolveScope = async (cwd, paths, repo) => {
   if (!paths.length) return { rev: null, paths };
   const first = paths[0];
-  if (await exists(path.resolve(cwd, first))) {
-    return { rev: null, paths };
-  }
+  if (await exists(path.resolve(cwd, first))) return { rev: null, paths };
   const resolved = repo.resolveRev(cwd, first);
   if (resolved) {
-    if (paths.length > 1) {
-      throw new Error('use a commit or a path, not both');
-    }
+    if (paths.length > 1) throw new Error('use a commit or a path, not both');
     return { rev: resolved, paths: [] };
   }
-  if (looksLikeRev(first)) {
-    throw new Error(`bad revision ${first}`);
-  }
+  if (looksLikeRev(first)) throw new Error(`bad revision ${first}`);
   return { rev: null, paths };
 };
 
-const sessionOptions = (proc, deps, args, env, extra) => ({
-  cwd: deps.cwd ?? proc.cwd(),
-  stdin: proc.stdin,
-  stdout: proc.stdout,
-  color: proc.stdout.isTTY === true && !env.NO_COLOR,
-  startPane: 'files',
-  newReview: args.newReview,
-  readOnly: args.readOnly,
-  audit: true,
-  ...extra,
-});
-
-const openLocalSession = async (proc, deps, args, selected, env) => {
-  const cwd = deps.cwd ?? proc.cwd();
+const localOptions = async (deps, args, selected, cwd) => {
   const rawRepo = deps.repo ?? createGitRepo();
   const scope = await resolveScope(cwd, selected.paths, rawRepo);
   const kind = scope.rev ? 'commit' : 'local';
   const capabilities = capabilitiesFor(kind, { readOnly: args.readOnly });
-  const repo = attachCapabilities(rawRepo, capabilities);
-  const extra = {
-    repo,
+  const direct = scope.rev || scope.paths.length;
+  return {
+    repo: attachCapabilities(rawRepo, capabilities),
     paths: scope.paths,
     rev: scope.rev,
     capabilities,
+    startPane: direct ? 'files' : 'dashboard',
   };
-  const options = sessionOptions(proc, deps, args, env, extra);
-  const session = new Session(options);
-  session.ensureRepo();
-  return session;
 };
 
 const remoteRepo = (deps, selected, env, cwd) => {
@@ -160,28 +119,34 @@ const remoteRepo = (deps, selected, env, cwd) => {
   });
 };
 
-const openRemoteSession = (proc, deps, args, selected, env) => {
+const remoteOptions = (deps, args, selected, cwd, env) => ({
+  repo: remoteRepo(deps, selected, env, cwd),
+  paths: selected.paths,
+  capabilities: capabilitiesFor(selected.kind, { readOnly: args.readOnly }),
+});
+
+const loadSession = async (proc, deps, args) => {
+  const env = proc.env ?? {};
   const cwd = deps.cwd ?? proc.cwd();
-  const capabilities = capabilitiesFor(selected.kind, {
+  const selected = selectChangeSource(args.paths);
+  const extra = REMOTE_CHANGE[selected.kind]
+    ? remoteOptions(deps, args, selected, cwd, env)
+    : await localOptions(deps, args, selected, cwd);
+  const session = new Session({
+    cwd,
+    stdin: proc.stdin,
+    stdout: proc.stdout,
+    color: proc.stdout.isTTY === true && !env.NO_COLOR,
+    startPane: 'files',
+    newReview: args.newReview,
     readOnly: args.readOnly,
+    audit: true,
+    ...extra,
   });
-  const repo = remoteRepo(deps, selected, env, cwd);
-  const extra = { repo, paths: selected.paths, capabilities };
-  const options = sessionOptions(proc, deps, args, env, extra);
-  const session = new Session(options);
   session.ensureRepo();
   return session;
 };
 
-const loadSession = async (proc, deps, args) => {
-  const env = proc.env ?? {};
-  const selected = selectChangeSource(args.paths);
-  if (REMOTE_CHANGE[selected.kind]) {
-    return openRemoteSession(proc, deps, args, selected, env);
-  }
-  return openLocalSession(proc, deps, args, selected, env);
-};
-
 const runUi = async (session, proc) => {
   const code = await session.startUi();
   if (session.loadError) return fail(proc.stderr, session.loadError);
@@ -196,7 +161,7 @@ const run = async (proc, deps = {}) => {
   const stderr = proc.stderr;
   let args;
   try {
-    args = parseArgv(proc.argv.slice(2));
+    args = parseArgv(argv);
   } catch (error) {
     fail(stderr, error);
     stderr.write(`${USAGE}\n`);
@@ -228,5 +193,6 @@ module.exports = {
   errorMessage,
   parseArgv,
   resolveScope,
+  loadSession,
   run,
 };

package/lib/clipboard.js

@@ -6,62 +6,46 @@ const { spawnSync } = childProcess;
 const ansi = require('./ansi.js');
 const { ESC } = ansi;
 const utilities = require('./utilities.js');
-const { clipTools, spawnBase } = utilities;
+const { spawnBase } = utilities;
 
 const CLIP_TIMEOUT_MS = 1000;
 
-const osc52 = (text) => {
-  const b64 = Buffer.from(text, 'utf8').toString('base64');
-  return `${ESC}]52;c;${b64}\x07`;
+const COPY_TOOLS = {
+  win32: [{ cmd: 'clip', args: [] }],
+  darwin: [{ cmd: 'pbcopy', args: [] }],
+  unix: [
+    { cmd: 'wl-copy', args: [] },
+    { cmd: 'xclip', args: ['-selection', 'clipboard'] },
+    { cmd: 'xsel', args: ['--clipboard', '--input'] },
+  ],
 };
 
-const runClip = (cmd, args, text) => {
-  const result = spawnSync(
-    cmd,
-    args,
-    spawnBase({
-      input: text,
-      encoding: 'utf8',
-      timeout: CLIP_TIMEOUT_MS,
-    }),
-  );
-  if (result.error) return false;
-  return result.status === 0;
+const PASTE_TOOLS = {
+  win32: [
+    { cmd: 'powershell', args: ['-NoProfile', '-Command', 'Get-Clipboard'] },
+  ],
+  darwin: [{ cmd: 'pbpaste', args: [] }],
+  unix: [
+    { cmd: 'wl-paste', args: ['--no-newline'] },
+    { cmd: 'xclip', args: ['-selection', 'clipboard', '-o'] },
+    { cmd: 'xsel', args: ['--clipboard', '--output'] },
+  ],
 };
 
-const UNIX_PASTE = [
-  { cmd: 'wl-paste', args: ['--no-newline'] },
-  { cmd: 'xclip', args: ['-selection', 'clipboard', '-o'] },
-  { cmd: 'xsel', args: ['--clipboard', '--output'] },
-];
-
 let copied = '';
 
-const pasteTools = (platform = process.platform) => {
-  if (platform === 'win32') {
-    const args = ['-NoProfile', '-Command', 'Get-Clipboard'];
-    return [{ cmd: 'powershell', args }];
-  }
-  if (platform === 'darwin') return [{ cmd: 'pbpaste', args: [] }];
-  return UNIX_PASTE;
-};
+const platformTools = (tools) => tools[process.platform] ?? tools.unix;
 
-const readPaste = (cmd, args) => {
-  const result = spawnSync(
-    cmd,
-    args,
-    spawnBase({ encoding: 'utf8', timeout: CLIP_TIMEOUT_MS }),
+const runTool = (tool, input) =>
+  spawnSync(
+    tool.cmd,
+    tool.args,
+    spawnBase({ input, encoding: 'utf8', timeout: CLIP_TIMEOUT_MS }),
   );
-  if (result.error || result.status !== 0) return '';
-  return result.stdout || '';
-};
 
-const systemPaste = () => {
-  for (const tool of pasteTools()) {
-    const text = readPaste(tool.cmd, tool.args);
-    if (text) return text;
-  }
-  return '';
+const osc52 = (text) => {
+  const b64 = Buffer.from(text, 'utf8').toString('base64');
+  return `${ESC}]52;c;${b64}\x07`;
 };
 
 const copyText = (text, stdout) => {
@@ -72,12 +56,20 @@ const copyText = (text, stdout) => {
     stdout.write(osc52(text));
     ok = true;
   }
-  for (const tool of clipTools()) {
-    if (runClip(tool.cmd, tool.args, text)) return true;
+  for (const tool of platformTools(COPY_TOOLS)) {
+    const result = runTool(tool, text);
+    if (!result.error && result.status === 0) return true;
   }
   return ok;
 };
 
-const pasteText = () => systemPaste() || copied;
+const pasteText = () => {
+  for (const tool of platformTools(PASTE_TOOLS)) {
+    const result = runTool(tool);
+    if (result.error || result.status !== 0) continue;
+    if (result.stdout) return result.stdout;
+  }
+  return copied;
+};
 
 module.exports = { osc52, copyText, pasteText };

package/lib/dashboard/git.js

@@ -0,0 +1,128 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const worktree = require('../git-worktree.js');
+const { runGitAsync } = worktree;
+
+const UNIT = '\x1f';
+const RECENT_COUNT = 8;
+const BRANCH_FORMAT = [
+  '%(HEAD)',
+  '%(refname:short)',
+  '%(objectname:short)',
+  '%(committerdate:unix)',
+  '%(upstream:short)',
+  '%(upstream:track)',
+  '%(subject)',
+].join('%09');
+const LAST_FORMAT = ['%H', '%h', '%ct', '%s'].join('%x1f');
+const PROBES = {
+  total: ['rev-list', '--count', 'HEAD'],
+  recent: ['log', `--max-count=${RECENT_COUNT}`, `--format=${LAST_FORMAT}`],
+  refs: ['for-each-ref', `--format=${BRANCH_FORMAT}`, 'refs/heads'],
+  dir: ['rev-parse', '--absolute-git-dir'],
+};
+const TRACK_AHEAD = /ahead (\d+)/;
+const TRACK_BEHIND = /behind (\d+)/;
+
+const gitText = async (top, args) => {
+  try {
+    const result = await runGitAsync(args, top);
+    return result.status === 0 ? result.stdout.trim() : '';
+  } catch {
+    return '';
+  }
+};
+
+const countOf = (text) => {
+  const value = parseInt(text, 10);
+  return Number.isFinite(value) ? value : 0;
+};
+
+const msOf = (seconds) => (Number.isFinite(seconds) ? seconds * 1000 : 0);
+
+const parseLines = (text, parse) => text.split('\n').map(parse).filter(Boolean);
+
+const parseTrack = (text) => {
+  const raw = `${text ?? ''}`;
+  const ahead = TRACK_AHEAD.exec(raw);
+  const behind = TRACK_BEHIND.exec(raw);
+  return {
+    ahead: ahead ? Number(ahead[1]) : 0,
+    behind: behind ? Number(behind[1]) : 0,
+    gone: raw.includes('gone'),
+  };
+};
+
+const parseBranch = (line) => {
+  const parts = line.split('\t');
+  const name = (parts[1] ?? '').trim();
+  if (!name) return null;
+  return {
+    name,
+    current: parts[0].includes('*'),
+    sha: (parts[2] ?? '').trim(),
+    at: msOf(Number(parts[3])),
+    upstream: (parts[4] ?? '').trim(),
+    ...parseTrack(parts[5]),
+    subject: parts.slice(6).join('\t').trim(),
+  };
+};
+
+const parseCommit = (line) => {
+  const parts = line.split(UNIT);
+  if (parts.length < 4 || !parts[0]) return null;
+  return {
+    sha: parts[0],
+    short: parts[1],
+    at: msOf(Number(parts[2])),
+    subject: parts.slice(3).join(UNIT).trim(),
+  };
+};
+
+const readNumber = (file) => {
+  try {
+    return countOf(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return 0;
+  }
+};
+
+const readStep = (dir, step, total) => ({
+  step: readNumber(path.join(dir, step)),
+  total: readNumber(path.join(dir, total)),
+});
+
+const rebaseState = (gitDir) => {
+  if (!gitDir) return null;
+  const merge = path.join(gitDir, 'rebase-merge');
+  if (fs.existsSync(merge)) return readStep(merge, 'msgnum', 'end');
+  const apply = path.join(gitDir, 'rebase-apply');
+  if (fs.existsSync(apply)) return readStep(apply, 'next', 'last');
+  return null;
+};
+
+const readGitSummary = async (top) => {
+  const names = Object.keys(PROBES);
+  const read = (name) => gitText(top, PROBES[name]);
+  const texts = await Promise.all(names.map(read));
+  const probes = {};
+  for (let i = 0; i < names.length; i++) probes[names[i]] = texts[i];
+  const branches = parseLines(probes.refs, parseBranch);
+  const current = branches.find((entry) => entry.current);
+  const recent = parseLines(probes.recent, parseCommit);
+  return {
+    branch: current ? current.name : '',
+    rebase: rebaseState(probes.dir),
+    commits: {
+      total: countOf(probes.total),
+      last: recent[0] ?? null,
+      recent,
+    },
+    branches,
+  };
+};
+
+module.exports = { readGitSummary, parseTrack };