@nimbus-sh/worker 0.9.0 → 0.11.0

package/dist/git/commands.js

@@ -1,9 +1,9 @@
 /**
- * git-commands.ts — Nimbus v2.0 Git integration via isomorphic-git.
+ * git/commands.ts — Nimbus v2.0 Git integration via isomorphic-git.
  *
  * Provides a full `git` command with subcommands:
- * init, clone, status, add, commit, log, branch, checkout,
- * diff, remote, fetch, pull, push, merge, reset, tag, stash
+ * init, clone, status, add, commit, log, branch, checkout, diff,
+ * ls-files, rev-parse, remote, fetch, pull, push, merge, reset, tag
  *
  * Uses a VFS→isomorphic-git FS adapter that maps all operations
  * to the SqliteVFS.
@@ -11,18 +11,20 @@
 import { requireVfsCred } from '@nimbus-sh/core/runtime/os-contracts.js';
 import { execGitNetwork } from './network-facet.js';
 import { normalizeVfsPath } from '@nimbus-sh/core/vfs/path.js';
-import { dec } from '@nimbus-sh/core/_shared/bytes.js';
+import { dec, enc } from '@nimbus-sh/core/_shared/bytes.js';
+import { DEFAULT_CONTEXT, DEFAULT_RENAME_SCORE, absentSpec, bytesFromBinary, detectRenames, formatNameOnly, formatNameStatus, formatPatch, formatStat, parseRenameScore, pathLine, statFile, } from './unified-diff.js';
 // ── Lazy-loaded isomorphic-git (avoid ~1MB load on every cold start) ────
 // NOTE: local git ops (init, status, add, commit, log, branch, checkout,
-// diff, remote, merge, reset, tag, config) run here in the supervisor DO.
+// diff, ls-files, rev-parse, remote, merge, reset, tag, config) run here in the supervisor DO.
 // Network ops (clone, fetch, pull) are delegated to the git-network-facet
 // because the supervisor's CPU budget cannot handle packfile processing
 // for real-world repos (>100 files).
 let _git = null;
 async function getGit() {
     if (!_git) {
-        // @ts-ignore — CF-compatible fork (github:AshishKumar4/cf-git)
-        _git = await import('isomorphic-git');
+        // Same patched build artifact used by the network facet. A fresh npm
+        // consumer does not run Nimbus' repository dependency-patching hook.
+        _git = (await import('../../vendor/git.generated.mjs')).git;
     }
     return _git;
 }
@@ -46,20 +48,89 @@ function wantsUtf8(options) {
  * Creates an isomorphic-git compatible `fs` object from SqliteVFS.
  * isomorphic-git requires: readFile, writeFile, unlink, readdir,
  * mkdir, rmdir, stat, lstat (all as promises).
+ *
+ * With a `worktree`, the adapter writes that worktree the way git's checkout
+ * does (entry.c create_directories, has_symlink_leading_path): below its top,
+ * `.git` aside, every leading component is lstat'd, and one that is not a real
+ * directory (a link, dangling or not, or a file) is replaced by one rather than
+ * followed, and a file replaces a link at its own path instead of writing
+ * through it. Components above the top are followed, as git follows them.
+ * Commands that only read the worktree or write `.git` pass no worktree.
  */
-function createGitFs(vfs) {
-    // Path normalization is shared with esbuild-service via ./vfs-path.ts.
+function createGitFs(vfs, worktree = null) {
+    // Path normalization is shared with esbuild-service via @nimbus-sh/core/vfs/path.js.
     // isomorphic-git constructs paths like `dir + '/' + filepath` which can
     // produce `/home/user/project/.` or paths with `..` segments — those are
     // collapsed before VFS lookup. The bounded `..` pop won't escape root.
     const normalizePath = normalizeVfsPath;
-    function ensureParent(p) {
-        const parts = normalizePath(p).split('/');
-        for (let i = 1; i < parts.length; i++) {
+    const top = worktree === null ? null : normalizePath(worktree);
+    const below = top ? `${top}/` : '';
+    const gitdir = `${below}.git`;
+    function lstatOrNull(p) {
+        try {
+            return vfs.lstat(p);
+        }
+        catch {
+            return null;
+        }
+    }
+    /** A path git's checkout owns: inside the worktree, not its top, not in its .git. */
+    function checkedOut(p) {
+        return top !== null && p.startsWith(below) && p !== gitdir && !p.startsWith(`${gitdir}/`);
+    }
+    /** `p`'s directories, down to `p` itself when `self`; see createGitFs for the worktree's rule. */
+    function ensureDirectories(p, self) {
+        const parts = p.split('/');
+        for (let i = 1; i <= (self ? parts.length : parts.length - 1); i++) {
             const dir = parts.slice(0, i).join('/');
-            if (dir && !vfs.exists(dir))
-                vfs.mkdir(dir, { recursive: true });
+            if (!dir)
+                continue;
+            if (!checkedOut(dir)) {
+                if (!vfs.exists(dir))
+                    vfs.mkdir(dir, { recursive: true });
+                continue;
+            }
+            const st = lstatOrNull(dir);
+            if (st?.type === 'directory')
+                continue;
+            if (st)
+                vfs.unlink(dir);
+            vfs.mkdir(dir);
+        }
+    }
+    // The inode as Node's fs.Stats: git's stat cache compares ctime, ino, uid and gid too.
+    function statsOf(filepath, follow) {
+        const p = normalizePath(filepath);
+        let st;
+        if (!p) {
+            const now = Date.now();
+            st = { dev: 0, ino: 0, nlink: 1, type: 'directory', size: 0, atime: now, ctime: now, mtime: now, mode: 0o755, uid: 0, gid: 0 };
+        }
+        else {
+            try {
+                st = follow ? vfs.stat(p) : vfs.lstat(p);
+            }
+            catch {
+                const err = new Error(`ENOENT: no such file or directory, ${follow ? 'stat' : 'lstat'} '${filepath}'`);
+                err.code = 'ENOENT';
+                err.errno = -2;
+                throw err;
+            }
         }
+        const isDir = st.type === 'directory';
+        const isLink = st.type === 'symlink';
+        return {
+            isFile: () => st.type === 'file',
+            isDirectory: () => isDir,
+            isSymbolicLink: () => isLink,
+            size: st.size,
+            mode: (isLink ? 0o120000 : isDir ? 0o040000 : 0o100000) | (st.mode & 0o7777),
+            mtimeMs: st.mtime, mtime: new Date(st.mtime),
+            ctimeMs: st.ctime, ctime: new Date(st.ctime),
+            atimeMs: st.atime, atime: new Date(st.atime),
+            uid: st.uid, gid: st.gid, dev: st.dev, ino: st.ino, nlink: st.nlink,
+            type: isDir ? 'dir' : isLink ? 'symlink' : 'file',
+        };
     }
     return {
         promises: {
@@ -81,7 +152,13 @@ function createGitFs(vfs) {
             },
             async writeFile(filepath, data, opts) {
                 const p = normalizePath(filepath);
-                ensureParent(p);
+                ensureDirectories(p, false);
+                // A file replaces a link or a directory at its own path (entry.c checkout_entry, remove_subtree).
+                const existing = checkedOut(p) ? lstatOrNull(p)?.type : undefined;
+                if (existing === 'symlink')
+                    vfs.unlink(p);
+                else if (existing === 'directory')
+                    vfs.removeRecursive(p);
                 if (typeof data === 'string') {
                     vfs.writeFile(p, data);
                 }
@@ -91,7 +168,7 @@ function createGitFs(vfs) {
             },
             async unlink(filepath) {
                 const p = normalizePath(filepath);
-                if (vfs.exists(p))
+                if (lstatOrNull(p))
                     vfs.unlink(p);
             },
             async readdir(filepath) {
@@ -103,79 +180,82 @@ function createGitFs(vfs) {
                 return vfs.readdir(p).map(e => e.name);
             },
             async mkdir(filepath, opts) {
-                const p = normalizePath(filepath);
-                if (!vfs.exists(p))
-                    vfs.mkdir(p, { recursive: true });
+                ensureDirectories(normalizePath(filepath), true);
             },
             async rmdir(filepath) {
                 const p = normalizePath(filepath);
-                if (vfs.exists(p))
-                    vfs.rmdir(p);
+                const st = lstatOrNull(p);
+                if (!st)
+                    return;
+                // rmdir(2) of a link is ENOTDIR: it never removes the directory the link names.
+                if (st.type !== 'directory') {
+                    throw Object.assign(new Error(`ENOTDIR: not a directory, rmdir '${filepath}'`), { code: 'ENOTDIR', errno: -20 });
+                }
+                vfs.rmdir(p);
             },
             async stat(filepath) {
-                const p = normalizePath(filepath);
-                // Synthetic directory stat — used for root, '.', and known directories
-                function dirStat() {
-                    const now = Date.now();
-                    const d = new Date(now);
-                    return {
-                        isFile: () => false, isDirectory: () => true, isSymbolicLink: () => false,
-                        size: 0, mode: 0o755, type: 'dir',
-                        mtimeMs: now, mtime: d, ctimeMs: now, ctime: d, atimeMs: now, atime: d,
-                        uid: 1000, gid: 1000, dev: 0, ino: 0, nlink: 1,
-                    };
-                }
-                // Empty path (from '.', '/', etc.) = root directory
-                if (!p)
-                    return dirStat();
-                // Check if path is a known directory (even without VFS stat entry)
-                if (vfs.exists(p) && vfs.isDirectory(p))
-                    return dirStat();
-                let st;
-                try {
-                    st = vfs.stat(p);
-                }
-                catch {
-                    const err = new Error(`ENOENT: no such file or directory, stat '${filepath}'`);
-                    err.code = 'ENOENT';
-                    err.errno = -2;
-                    throw err;
-                }
-                // isomorphic-git calls .valueOf() on mtime/ctime/atime — all must be Date objects
-                const mtimeMs = st.mtime || Date.now();
-                const mtime = new Date(mtimeMs);
-                return {
-                    isFile: () => st.type === 'file',
-                    isDirectory: () => st.type === 'directory',
-                    isSymbolicLink: () => false,
-                    size: st.size,
-                    mode: st.mode || 0o644,
-                    mtimeMs,
-                    mtime,
-                    ctimeMs: mtimeMs,
-                    ctime: mtime,
-                    atimeMs: mtimeMs,
-                    atime: mtime,
-                    uid: 1000,
-                    gid: 1000,
-                    dev: 0,
-                    ino: 0,
-                    nlink: 1,
-                    type: st.type === 'directory' ? 'dir' : 'file',
-                };
+                return statsOf(filepath, true);
             },
             async lstat(filepath) {
-                return this.stat(filepath);
+                return statsOf(filepath, false);
             },
             async chmod() { },
-            async symlink() { },
-            async readlink(filepath) { return filepath; },
+            async symlink(target, filepath) {
+                const p = normalizePath(filepath);
+                ensureDirectories(p, false);
+                // Checkout retargets a link in place, as the clone facet's adapter does.
+                const st = lstatOrNull(p);
+                if (st?.type === 'directory' && checkedOut(p))
+                    vfs.removeRecursive(p);
+                else if (st && st.type !== 'directory')
+                    vfs.unlink(p);
+                vfs.symlink(target, p);
+            },
+            async readlink(filepath) {
+                return vfs.readlink(normalizePath(filepath));
+            },
         },
     };
 }
 function getDir(ctx) {
     return '/' + (ctx.cwd || '/home/user').replace(/^\/+/, '');
 }
+/**
+ * The options git accepts BEFORE the subcommand. `-C <path>` runs the
+ * command as if started from <path>; repeated, each is relative to the
+ * previous (`git -C a -C b` runs in `a/b`). `--no-pager` and `-P` are
+ * accepted and mean nothing here, there is no pager. Any other leading
+ * option is refused: swallowing it would run the next word as a subcommand.
+ */
+export function parseGitGlobals(args, cwd) {
+    let dir = cwd;
+    let i = 0;
+    for (; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '-C') {
+            const path = args[++i];
+            if (path === undefined)
+                throw new Error("option '-C' requires a value");
+            dir = path.startsWith('/') ? path : dir + '/' + path;
+            dir = '/' + dir.split('/').filter((seg) => seg && seg !== '.').join('/');
+        }
+        else if (arg.startsWith('-C') && arg.length > 2) {
+            const path = arg.slice(2);
+            dir = path.startsWith('/') ? path : dir + '/' + path;
+            dir = '/' + dir.split('/').filter((seg) => seg && seg !== '.').join('/');
+        }
+        else if (arg === '--no-pager' || arg === '-P') {
+            // no pager to disable
+        }
+        else if (arg.startsWith('-') && arg !== '--version' && arg !== '-v' && arg !== '--help' && arg !== '-h') {
+            throw new Error(`unknown option '${arg}'\nusage: git [-C <path>] [--no-pager] <command> [<args>]`);
+        }
+        else {
+            break;
+        }
+    }
+    return { sub: args[i], subArgs: args.slice(i + 1), dir };
+}
 function getFlag(args, flag) {
     const idx = args.indexOf(flag);
     if (idx >= 0)
@@ -183,7 +263,7 @@ function getFlag(args, flag) {
     const prefix = `${flag}=`;
     return args.find((arg) => arg.startsWith(prefix))?.slice(prefix.length) || undefined;
 }
-export const CLONE_USAGE = 'usage: git clone [--depth <n>] [--no-shallow] [--branch <name> | -b <name>] [--bg] <url> [dir]';
+export const CLONE_USAGE = 'usage: git clone [-q | --quiet] [--depth <n>] [--no-shallow] [--branch <name> | -b <name>] [--bg] <url> [dir]';
 /**
  * Every flag is either handled or refused loudly. Silently skipping unknown
  * flags corrupted positionals for value-taking ones (`--branch dev URL`
@@ -195,6 +275,7 @@ export function parseCloneArgs(args) {
     let branch;
     let noShallow = false;
     let isBg = false;
+    let quiet = false;
     const positionals = [];
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
@@ -217,6 +298,10 @@ export function parseCloneArgs(args) {
             noShallow = true;
         else if (arg === '--bg' || arg === '&')
             isBg = true;
+        else if (arg === '-q' || arg === '--quiet')
+            quiet = true;
+        // Progress is already the default; there is no more of it to ask for.
+        else if (arg === '-v' || arg === '--verbose') { /* accepted */ }
         else if (name === '--filter') {
             throw new Error("clone does not support '--filter': the bundled isomorphic-git has no " +
                 'partial-clone support, so a filter would silently download every object. ' +
@@ -236,13 +321,1579 @@ export function parseCloneArgs(args) {
         noShallow,
         isBg,
         branch,
+        quiet,
     };
 }
-function getAuthor(ctx) {
-    return {
-        name: ctx.env.GIT_AUTHOR_NAME || ctx.env.USER || 'user',
-        email: ctx.env.GIT_AUTHOR_EMAIL || 'user@nimbus.dev',
+/** fetch, pull and push: `-q`/`--quiet` wherever it appears; the other words keep their order. */
+function takeQuiet(args) {
+    const rest = args.filter((arg) => arg !== '-q' && arg !== '--quiet');
+    return { quiet: rest.length !== args.length, rest };
+}
+/** commit's -m (repeatable), -q and -a, bundled as git allows (`-qm msg`, `-mmsg`); other options stay ignored. */
+function parseCommitArgs(args) {
+    const messages = [];
+    let quiet = false;
+    let all = false;
+    let cleanup = null;
+    let allowEmptyMessage = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--')
+            break;
+        if (arg === '--quiet')
+            quiet = true;
+        else if (arg === '--all')
+            all = true;
+        else if (arg === '--allow-empty-message')
+            allowEmptyMessage = true;
+        else if (arg === '--cleanup')
+            cleanup = args[++i] ?? '';
+        else if (arg.startsWith('--cleanup='))
+            cleanup = arg.slice('--cleanup='.length);
+        else if (arg === '--message')
+            messages.push(args[++i] ?? '');
+        else if (arg.startsWith('--message='))
+            messages.push(arg.slice('--message='.length));
+        else if (/^-[^-]/.test(arg)) {
+            for (let j = 1; j < arg.length; j++) {
+                if (arg[j] === 'q')
+                    quiet = true;
+                else if (arg[j] === 'a')
+                    all = true;
+                else if (arg[j] === 'm') {
+                    messages.push(j + 1 < arg.length ? arg.slice(j + 1) : args[++i] ?? '');
+                    break;
+                }
+            }
+        }
+    }
+    return { messages, quiet, all, cleanup, allowEmptyMessage };
+}
+/**
+ * The message `-m` options make (builtin/commit.c opt_parse_m): each value
+ * ends in a newline, and one after another is joined by a blank line; an
+ * empty value adds nothing.
+ */
+function joinMessageOptions(values) {
+    let buf = '';
+    for (const value of values) {
+        if (buf.length)
+            buf += '\n';
+        buf += value;
+        if (buf.length && !buf.endsWith('\n'))
+            buf += '\n';
+    }
+    return buf;
+}
+/**
+ * The cleanup mode a commit message gets (builtin/commit.c): --cleanup, else
+ * commit.cleanup. With no editor, as for -m, `default` and `scissors` are
+ * `whitespace`. Null for a mode git does not know.
+ */
+function commitCleanupMode(value) {
+    if (value === undefined || value === 'default' || value === 'scissors' || value === 'whitespace')
+        return 'whitespace';
+    if (value === 'strip' || value === 'verbatim')
+        return value;
+    return null;
+}
+function isNotFound(error) {
+    return error instanceof Error && 'code' in error && error.code === 'NotFoundError';
+}
+// ── Output ───────────────────────────────────────────────────────────────
+/** Emit a binary string: its bytes verbatim where the sink keeps bytes, else as UTF-8 text. */
+async function writeBinary(stream, bin) {
+    if (!bin)
+        return;
+    const bytes = bytesFromBinary(bin);
+    if (stream.writeBytes)
+        await stream.writeBytes(bytes);
+    else
+        await stream.write(dec.decode(bytes));
+}
+// ── Staging ──────────────────────────────────────────────────────────────
+/**
+ * `commit -a`'s staging of tracked changes: the status refresh, the removals
+ * and the additions under one index write, as git's, and a path at a time
+ * (1,000 concurrent deflates reset the isolate).
+ */
+async function stageTracked(git, fs, dir) {
+    const cache = {};
+    const added = [];
+    const removed = [];
+    for (const [filepath, head, workdir, stage] of await git.statusMatrix({ fs, dir, cache, deferRefresh: true })) {
+        if (stage === 0)
+            continue;
+        if (head === workdir && workdir === stage)
+            continue;
+        if (workdir === 0)
+            removed.push(filepath);
+        else
+            added.push(filepath);
+    }
+    await git.stage({ fs, dir, cache, add: added, remove: removed, parallel: false });
+}
+// ── Repository discovery ─────────────────────────────────────────────────
+const NOT_A_REPOSITORY = 'fatal: not a git repository (or any of the parent directories): .git\n';
+const NOT_A_WORK_TREE = 'fatal: this operation must be run in a work tree\n';
+/** setup_git_directory's walk: from the cwd up, a `.git` inside each level, else the level itself as a git directory. */
+function discoverRepo(vfs, cwd) {
+    const isGitDir = (key) => {
+        const sub = (name) => (key ? `${key}/${name}` : name);
+        return vfs.isFile(sub('HEAD')) && vfs.isDirectory(sub('objects')) && vfs.isDirectory(sub('refs'));
+    };
+    const segments = normalizeVfsPath(cwd).split('/').filter(Boolean);
+    for (let depth = segments.length; depth >= 0; depth--) {
+        const dir = segments.slice(0, depth).join('/');
+        const prefix = segments.slice(depth).join('/');
+        const dotGit = dir ? `${dir}/.git` : '.git';
+        if (isGitDir(dotGit))
+            return { gitdir: `/${dotGit}`, worktree: `/${dir}`, prefix };
+        if (isGitDir(dir))
+            return { gitdir: `/${dir}`, worktree: null, prefix };
+    }
+    return null;
+}
+function ambiguousArgument(arg) {
+    return `fatal: ambiguous argument '${arg}': unknown revision or path not in the working tree.\n`
+        + "Use '--' to separate paths from revisions, like this:\n"
+        + "'git <command> [<revision>...] -- [<file>...]'\n";
+}
+/** A revision as rev-parse reads one: a ref, or a full or uniquely abbreviated object name. */
+async function resolveRevision(git, fs, gitdir, rev, cache) {
+    const name = rev === '@' ? 'HEAD' : rev;
+    if (/[~^:{}\\]|\.\.|^@/.test(name))
+        throw new Error(`unsupported revision syntax '${rev}'`);
+    try {
+        return await git.resolveRef({ fs, gitdir, ref: name });
+    }
+    catch (e) {
+        if (!isNotFound(e))
+            throw e;
+    }
+    if (!/^[0-9a-f]{4,39}$/.test(name))
+        return null;
+    try {
+        return await git.expandOid({ fs, gitdir, oid: name, cache });
+    }
+    catch (e) {
+        if (!isNotFound(e))
+            throw e;
+        return null;
+    }
+}
+/** --abbrev-ref: the short name of the ref a revision spells, null when it spells none. */
+async function abbreviatedRef(git, fs, gitdir, rev) {
+    if (rev === 'HEAD' || rev === '@')
+        return (await git.currentBranch({ fs, gitdir })) ?? 'HEAD';
+    try {
+        const full = await git.expandRef({ fs, gitdir, ref: rev });
+        return full.replace(/^refs\/remotes\/(.+)\/HEAD$/, '$1').replace(/^refs\/(?:heads|tags|remotes)\//, '');
+    }
+    catch (e) {
+        if (!isNotFound(e))
+            throw e;
+        return null;
+    }
+}
+async function revParse(ctx, git, fs, vfs, args) {
+    const repo = discoverRepo(vfs, ctx.cwd);
+    if (!repo) {
+        await ctx.stderr.write(NOT_A_REPOSITORY);
+        return 128;
+    }
+    const cache = {};
+    let verify = false;
+    let quiet = false;
+    let abbrevRef = false;
+    let out = '';
+    const verified = [];
+    const show = async (rev, oid) => {
+        if (!abbrevRef)
+            return `${oid}\n`;
+        const name = await abbreviatedRef(git, fs, repo.gitdir, rev);
+        return name === null ? '' : `${name}\n`;
+    };
+    const fail = async (message, code) => {
+        if (out)
+            await ctx.stdout.write(out);
+        if (message)
+            await ctx.stderr.write(message);
+        return code;
+    };
+    const noSingleRevision = () => (quiet ? fail('', 1) : fail('fatal: Needed a single revision\n', 128));
+    for (const arg of args) {
+        switch (arg) {
+            case '--verify':
+                verify = true;
+                continue;
+            case '-q':
+            case '--quiet':
+                quiet = true;
+                continue;
+            case '--abbrev-ref':
+                abbrevRef = true;
+                continue;
+            case '--show-toplevel':
+                if (!repo.worktree)
+                    return fail(NOT_A_WORK_TREE, 128);
+                out += `${repo.worktree}\n`;
+                continue;
+            case '--git-dir':
+                // rev-parse names the git directory relative to the cwd only from the top.
+                out += `${repo.prefix ? repo.gitdir : repo.worktree ? '.git' : '.'}\n`;
+                continue;
+            case '--is-inside-work-tree':
+                out += `${repo.worktree ? 'true' : 'false'}\n`;
+                continue;
+        }
+        if (arg.startsWith('-'))
+            return fail(`fatal: rev-parse: unsupported option '${arg}'\n`, 129);
+        const oid = await resolveRevision(git, fs, repo.gitdir, arg, cache);
+        if (oid === null) {
+            if (verify)
+                return noSingleRevision();
+            // A non-revision is echoed as a path, which must then exist.
+            out += `${arg}\n`;
+            if (vfs.exists(normalizeVfsPath(arg.startsWith('/') ? arg : `${ctx.cwd}/${arg}`)))
+                continue;
+            return fail(ambiguousArgument(arg), 128);
+        }
+        if (verify)
+            verified.push({ rev: arg, oid });
+        else
+            out += await show(arg, oid);
+    }
+    if (verify) {
+        if (verified.length !== 1)
+            return noSingleRevision();
+        out += await show(verified[0].rev, verified[0].oid);
+    }
+    await ctx.stdout.write(out);
+    return 0;
+}
+// ── Worktree inspection (ls-files, diff) ─────────────────────────────────
+/** Whether git trusts the worktree's exec bit here: core.filemode, true unless set false. */
+async function trustsFileMode(git, fs, dir) {
+    return (await git.getConfig({ fs, dir, path: 'core.filemode' })) !== false;
+}
+/** ce_mode_from_stat: without a trusted exec bit a file keeps its index mode, or 100644 when new. */
+function worktreeMode(mode, indexMode, filemode) {
+    if (filemode || mode === 0o120000)
+        return mode;
+    return indexMode !== undefined && indexMode !== 0o120000 ? indexMode : 0o100644;
+}
+/** git's index and tree order: the UTF-8 bytes, which is code point order rather than UTF-16's. */
+function comparePaths(a, b) {
+    for (let i = 0; i < a.length && i < b.length; i++) {
+        let x = a.charCodeAt(i);
+        let y = b.charCodeAt(i);
+        if (x === y)
+            continue;
+        // Surrogates (astral code points) sort above the rest of the BMP.
+        if (x >= 0xd800)
+            x = x >= 0xe000 ? x - 0x800 : x + 0x2000;
+        if (y >= 0xd800)
+            y = y >= 0xe000 ? y - 0x800 : y + 0x2000;
+        return x - y;
+    }
+    return a.length - b.length;
+}
+/** A repo-relative path as seen from `prefix`, climbing with '../' where it must. */
+function relativeTo(path, prefix) {
+    if (!prefix)
+        return path;
+    if (path.startsWith(`${prefix}/`))
+        return path.slice(prefix.length + 1);
+    const from = prefix.split('/');
+    const to = path.split('/');
+    let shared = 0;
+    while (shared < from.length && shared < to.length - 1 && from[shared] === to[shared])
+        shared++;
+    return '../'.repeat(from.length - shared) + to.slice(shared).join('/');
+}
+/** Literal pathspecs, relative to the cwd, as repo-relative paths; '' is the whole tree. */
+function repoPaths(args, cwd, worktree) {
+    const root = normalizeVfsPath(worktree);
+    return args.map((arg) => {
+        if (/[*?[]/.test(arg))
+            throw new Error(`pathspec '${arg}': globs are not supported, name the paths`);
+        const key = normalizeVfsPath(arg.startsWith('/') ? arg : `${cwd}/${arg}`);
+        if (!root || key === root)
+            return root ? '' : key;
+        if (key.startsWith(`${root}/`))
+            return key.slice(root.length + 1);
+        throw new Error(`${arg}: '${arg}' is outside repository at '${worktree}'`);
+    });
+}
+/** cf-git's walk one entry at a time, not every sibling at once; `visit` answers whether to descend. */
+async function walkScoped(git, fs, dir, cache, trees, specs, visit) {
+    await git.walk({
+        fs, dir, cache, trees,
+        map: async (path, entries) => {
+            if (path === '.')
+                return true;
+            const inScope = specs.length === 0
+                || specs.some((spec) => spec === '' || path === spec || path.startsWith(`${spec}/`));
+            // Outside the pathspecs a directory is entered only on the way to one.
+            if (!inScope)
+                return specs.some((spec) => spec.startsWith(`${path}/`)) ? true : null;
+            return (await visit(path, entries)) ? true : null;
+        },
+        reduce: async () => undefined,
+        iterate: async (walk, children) => {
+            for (const child of children)
+                await walk(child);
+            return [];
+        },
+    });
+}
+const ADD_USAGE = 'usage: git add [-n | --dry-run] [-v | --verbose] [-f | --force] [-A | --all | --no-all] '
+    + '[-u | --update] [--] <pathspec>...\n';
+/** git add's options this git does not do: they are git's, so they are refused as unsupported, not unknown. */
+const ADD_UNSUPPORTED = new Set(['i', 'p', 'e', 'N', 'U', '--interactive', '--patch', '--edit', '--intent-to-add',
+    '--unified', '--inter-hunk-context', '--renormalize', '--refresh', '--ignore-errors', '--ignore-missing', '--sparse',
+    '--chmod', '--pathspec-from-file', '--pathspec-file-nul']);
+/**
+ * `git add`: what git 2.x stages for its pathspecs. A pathspec takes the
+ * changes, deletions and new files below it (as -A does); -u only tracked
+ * paths, --no-all no deletions, -A or -u with no pathspec the whole tree.
+ * -n prints what would be staged (`add 'p'`, `remove 'p'`, tracked paths
+ * first, then new ones) and stages nothing; -v prints it and stages. A
+ * pathspec that matches nothing fails before anything is staged; one that
+ * names an ignored path is reported (exit 1) unless -f, the rest still added.
+ */
+async function addCommand(ctx, git, fs, vfs, args) {
+    let dryRun = false;
+    let verbose = false;
+    let force = false;
+    let all = null;
+    let update = false;
+    let dashdash = false;
+    const pathArgs = [];
+    for (const arg of args) {
+        if (dashdash || arg === '-' || !arg.startsWith('-')) {
+            pathArgs.push(arg);
+            continue;
+        }
+        if (arg === '--') {
+            dashdash = true;
+            continue;
+        }
+        const flags = arg.startsWith('--') ? [arg.split('=')[0]] : [...arg.slice(1)];
+        for (const flag of flags) {
+            switch (flag) {
+                case 'n':
+                case '--dry-run':
+                    dryRun = true;
+                    break;
+                case 'v':
+                case '--verbose':
+                    verbose = true;
+                    break;
+                case 'f':
+                case '--force':
+                    force = true;
+                    break;
+                case 'A':
+                case '--all':
+                case '--no-ignore-removal':
+                    all = true;
+                    break;
+                case '--no-all':
+                case '--ignore-removal':
+                    all = false;
+                    break;
+                case 'u':
+                case '--update':
+                    update = true;
+                    break;
+                default:
+                    if (ADD_UNSUPPORTED.has(flag)) {
+                        await ctx.stderr.write(`fatal: git add ${flag.length === 1 ? `-${flag}` : flag} is not supported here\n`);
+                        return 128;
+                    }
+                    await ctx.stderr.write(flag.length === 1
+                        ? `error: unknown switch \`${flag}'\n${ADD_USAGE}`
+                        : `error: unknown option \`${flag.slice(2)}'\n${ADD_USAGE}`);
+                    return 129;
+            }
+        }
+    }
+    const repo = discoverRepo(vfs, ctx.cwd);
+    if (!repo) {
+        await ctx.stderr.write(NOT_A_REPOSITORY);
+        return 128;
+    }
+    const root = repo.worktree;
+    if (!root) {
+        await ctx.stderr.write(NOT_A_WORK_TREE);
+        return 128;
+    }
+    if (pathArgs.length === 0 && all !== true && !update) {
+        await ctx.stderr.write("Nothing specified, nothing added.\nhint: Maybe you wanted to say 'git add .'?\n"
+            + 'hint: Disable this message with "git config set advice.addEmptyPathspec false"\n');
+        return 0;
+    }
+    const specs = pathArgs.length ? repoPaths(pathArgs, ctx.cwd, root) : [''];
+    const inSpec = (path, spec) => spec === '' || path === spec || path.startsWith(`${spec}/`);
+    const cache = {};
+    // Its stat refreshes ride in the one index write that stages (git add writes once).
+    const matrix = await git.statusMatrix({ fs, dir: root, cache, deferRefresh: !dryRun });
+    // -f takes the ignored files below each pathspec as well.
+    const forced = force
+        ? await git.statusMatrix({ fs, dir: root, cache, ignored: true, filepaths: specs.map((spec) => spec || '.') })
+        : [];
+    const rows = new Map();
+    for (const [path, head, workdir, stage] of [...matrix, ...forced]) {
+        // -u updates what the index holds and nothing else: a path it does not
+        // hold (never added, or removed with rm --cached) is not git's to update.
+        if (update && stage === 0)
+            continue;
+        if (specs.some((spec) => inSpec(path, spec)))
+            rows.set(path, [head, workdir, stage]);
+    }
+    const ignored = [];
+    for (const [i, spec] of specs.entries()) {
+        if (spec === '' || [...rows.keys()].some((path) => inSpec(path, spec)))
+            continue;
+        if (update) {
+            // "Known to git" is the index; git names the first pathspec it holds nothing under.
+            await ctx.stderr.write(`error: pathspec '${pathArgs[i]}' did not match any file(s) known to git\n`);
+            return 128;
+        }
+        let st = null;
+        try {
+            st = vfs.lstat(normalizeVfsPath(`${root}/${spec}`));
+        }
+        catch { /* absent */ }
+        if (!st) {
+            await ctx.stderr.write(`fatal: pathspec '${pathArgs[i]}' did not match any files\n`);
+            return 128;
+        }
+        // Named but not listed: ignored (reported at the path the ignore rule names), or an empty directory.
+        const parts = spec.split('/');
+        for (let depth = 1; depth <= parts.length; depth++) {
+            const prefix = parts.slice(0, depth).join('/');
+            if (await git.isIgnored({ fs, dir: root, filepath: prefix })) {
+                if (!ignored.includes(prefix))
+                    ignored.push(prefix);
+                break;
+            }
+        }
+    }
+    const tracked = [];
+    const untracked = [];
+    for (const [path, [head, workdir, stage]] of [...rows].sort(([a], [b]) => comparePaths(a, b))) {
+        if (head === 0 && stage === 0) {
+            if (workdir !== 0 && !update)
+                untracked.push(path);
+            continue;
+        }
+        if (workdir === 0) {
+            if (stage !== 0 && all !== false)
+                tracked.push([path, 'remove']);
+        }
+        else if (stage !== workdir) {
+            tracked.push([path, 'add']);
+        }
+    }
+    if (ignored.length) {
+        await ctx.stderr.write(`The following paths are ignored by one of your .gitignore files:\n${ignored.map((p) => `${p}\n`).join('')}`
+            + 'hint: Use -f if you really want to add them.\n'
+            + 'hint: Disable this message with "git config set advice.addIgnoredFile false"\n');
+    }
+    let out = '';
+    for (const [path, action] of tracked)
+        out += `${action} '${path}'\n`;
+    for (const path of untracked)
+        out += `add '${path}'\n`;
+    if (dryRun || verbose)
+        await writeBinary(ctx.stdout, out);
+    if (!dryRun) {
+        const removed = tracked.filter(([, action]) => action === 'remove').map(([path]) => path);
+        const added = [...tracked.filter(([, action]) => action === 'add').map(([path]) => path), ...untracked];
+        await git.stage({ fs, dir: root, cache, add: added, remove: removed, parallel: false, force: true });
+    }
+    return ignored.length ? 1 : 0;
+}
+const TAG_USAGE = 'usage: git tag [-a] [-f] [-m <msg> | -F <file>] <tagname> [<commit>]\n'
+    + '   or: git tag -d <tagname>...\n'
+    + '   or: git tag [-n[<num>]] [-l] [<pattern>...]\n';
+/** git's `whitespace` cleanup of a message given with -m or -F: no trailing blanks, no runs or edges of empty lines. */
+/** A `±hhmm` timezone for an offset in minutes east of UTC. */
+function gitTimezone(minutesEast) {
+    const sign = minutesEast < 0 ? '-' : '+';
+    const abs = Math.abs(minutesEast);
+    return `${sign}${String(Math.floor(abs / 60)).padStart(2, '0')}${String(abs % 60).padStart(2, '0')}`;
+}
+// git's date.c tables, in its order: a name matches from its third letter on.
+const GIT_MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+const GIT_WEEKDAYS = ['Sundays', 'Mondays', 'Tuesdays', 'Wednesdays', 'Thursdays', 'Fridays', 'Saturdays'];
+/** [name, hours east, daylight]: git adds the daylight hour ("This is bogus, but we like summer"). */
+const GIT_ZONES = [
+    ['IDLW', -12, 0], ['NT', -11, 0], ['CAT', -10, 0], ['HST', -10, 0], ['HDT', -10, 1], ['YST', -9, 0], ['YDT', -9, 1],
+    ['PST', -8, 0], ['PDT', -8, 1], ['MST', -7, 0], ['MDT', -7, 1], ['CST', -6, 0], ['CDT', -6, 1], ['EST', -5, 0],
+    ['EDT', -5, 1], ['AST', -3, 0], ['ADT', -3, 1], ['WAT', -1, 0], ['GMT', 0, 0], ['UTC', 0, 0], ['Z', 0, 0],
+    ['WET', 0, 0], ['BST', 0, 1], ['CET', 1, 0], ['MET', 1, 0], ['MEWT', 1, 0], ['MEST', 1, 1], ['CEST', 1, 1],
+    ['MESZ', 1, 1], ['FWT', 1, 0], ['FST', 1, 1], ['EET', 2, 0], ['EEST', 2, 1], ['WAST', 7, 0], ['WADT', 7, 1],
+    ['CCT', 8, 0], ['JST', 9, 0], ['EAST', 10, 0], ['EADT', 10, 1], ['GST', 10, 0], ['NZT', 12, 0], ['NZST', 12, 0],
+    ['NZDT', 12, 1], ['IDLE', 12, 0],
+];
+const isDigit = (c) => c !== undefined && c >= '0' && c <= '9';
+const isAlpha = (c) => c !== undefined && /[A-Za-z]/.test(c);
+const isAlnum = (c) => isDigit(c) || isAlpha(c);
+/**
+ * A GIT_COMMITTER_DATE as git's date.c parse_date_basic() reads it, ported
+ * routine for routine (match_object_header_date, match_alpha, match_digit,
+ * match_multi_number, set_date, match_tz, tm_to_time_t), so every form git
+ * accepts is accepted and read the same way: `@<secs> ±hhmm` (git's own raw
+ * form), a bare epoch of 9 or more digits, ISO 8601, RFC 2822 (`date -R`),
+ * git's default `Thu Jan 2 03:04:05 2020 -0800`, dotted and slashed dates,
+ * zone names, am/pm. Without a zone, the local one at that time, as mktime()
+ * gives it. Null where git says "invalid date format": no time of day, a
+ * year outside 1970-2099, a date it cannot place.
+ */
+function parseGitDate(text, nowSeconds = Math.floor(Date.now() / 1000)) {
+    // match_object_header_date: "@<digits> ±hhmm", exactly.
+    const header = /^@(\d+) ([+-])(\d{4})(?:\n|$)/.exec(text);
+    if (header) {
+        const hhmm = Number(header[3]);
+        const minutes = (header[2] === '-' ? -1 : 1) * (Math.floor(hhmm / 100) * 60 + (hhmm % 100));
+        return { seconds: Number(header[1]), zone: gitTimezone(minutes) };
+    }
+    const tm = { year: -1, mon: -1, mday: -1, hour: -1, min: -1, sec: -1, wday: -1 };
+    let offset = null;
+    let gmt = false;
+    // tm_to_time_t: 1970-2099 only, and every field of the time of day given.
+    const toTime = (t) => {
+        const days = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
+        const year = t.year - 70;
+        let day = t.mday;
+        if (year < 0 || year > 129 || t.mon < 0 || t.mon > 11)
+            return null;
+        if (t.mon < 2 || (year + 2) % 4)
+            day--;
+        if (t.hour < 0 || t.min < 0 || t.sec < 0)
+            return null;
+        return (year * 365 + Math.floor((year + 1) / 4) + days[t.mon] + day) * 86_400 + t.hour * 3600 + t.min * 60 + t.sec;
     };
+    const noDate = () => tm.year < 0 && tm.mon < 0 && tm.mday < 0 && tm.hour < 0 && tm.min < 0 && tm.sec < 0;
+    const matchString = (at, word) => {
+        let i = 0;
+        for (; at + i < text.length; i++) {
+            const c = text[at + i];
+            if (c === word[i] || c.toUpperCase() === (word[i] ?? '').toUpperCase())
+                continue;
+            if (!isAlnum(c))
+                break;
+            return 0;
+        }
+        return i;
+    };
+    // set_date: month and day in range, the year placed as git places it, and
+    // (for a guessed order) no more than ten days into the future.
+    const setDate = (year, month, day, refuseFuture) => {
+        if (!(month > 0 && month < 13 && day > 0 && day < 32))
+            return false;
+        const r = { ...tm, mon: month - 1, mday: day };
+        if (year === -1) {
+            if (!refuseFuture)
+                return false;
+            r.year = new Date(nowSeconds * 1000).getUTCFullYear() - 1900;
+        }
+        else if (year >= 1970 && year < 2100)
+            r.year = year - 1900;
+        else if (year > 70 && year < 100)
+            r.year = year;
+        else if (year < 38)
+            r.year = year + 100;
+        else
+            return false;
+        if (refuseFuture) {
+            const specified = toTime({ ...r, hour: 0, min: 0, sec: 0 });
+            if (specified !== null && nowSeconds + 10 * 86_400 < specified)
+                return false;
+        }
+        tm.mon = r.mon;
+        tm.mday = r.mday;
+        if (year !== -1 || !refuseFuture)
+            tm.year = r.year;
+        return true;
+    };
+    const readNumber = (at) => {
+        let end = at;
+        while (isDigit(text[end]))
+            end++;
+        return [Number(text.slice(at, end)), end];
+    };
+    const matchMulti = (num, sep, at, end) => {
+        let num3 = -1;
+        let [num2, next] = readNumber(end + 1);
+        if (text[next] === sep && isDigit(text[next + 1]))
+            [num3, next] = readNumber(next + 1);
+        if (sep === ':') {
+            if (num3 < 0)
+                num3 = 0;
+            if (num < 25 && num2 >= 0 && num2 < 60 && num3 >= 0 && num3 <= 60) {
+                tm.hour = num;
+                tm.min = num2;
+                tm.sec = num3;
+                return next - at;
+            }
+            return 0;
+        }
+        if (num > 70 && (setDate(num, num2, num3, false) || setDate(num, num3, num2, false)))
+            return next - at;
+        if (sep !== '.' && setDate(num3, num, num2, true))
+            return next - at;
+        if (setDate(num3, num2, num, true))
+            return next - at;
+        if (sep === '.' && setDate(num3, num, num2, true))
+            return next - at;
+        return 0;
+    };
+    const matchDigit = (at) => {
+        const [num, end] = readNumber(at);
+        // Seconds since 1970: a number of 9 digits or more, before any date.
+        if (num >= 100_000_000 && noDate()) {
+            const d = new Date(num * 1000);
+            Object.assign(tm, { year: d.getUTCFullYear() - 1900, mon: d.getUTCMonth(), mday: d.getUTCDate(), hour: d.getUTCHours(), min: d.getUTCMinutes(), sec: d.getUTCSeconds() });
+            gmt = true;
+            return end - at;
+        }
+        if ((text[end] === ':' || text[end] === '.' || text[end] === '/' || text[end] === '-') && isDigit(text[end + 1])) {
+            const matched = matchMulti(num, text[end], at, end);
+            if (matched)
+                return matched;
+        }
+        const n = end - at;
+        if (n === 8 || n === 6) {
+            const [a, b, c] = [Math.floor(num / 10000), Math.floor((num % 10000) / 100), num % 100];
+            if (n === 8)
+                setDate(a, b, c, false);
+            else if (a < 25 && b < 60 && c <= 60) {
+                tm.hour = a;
+                tm.min = b;
+                tm.sec = c;
+                if (text[end] === '.' && isDigit(text[end + 1]))
+                    return readNumber(end + 1)[1] - at;
+            }
+            return n;
+        }
+        if (n === 4) {
+            if (num <= 1400 && offset === null)
+                offset = Math.floor(num / 100) * 60 + (num % 100);
+            else if (num > 1900 && num < 2100)
+                tm.year = num - 1900;
+            return n;
+        }
+        if (n > 2)
+            return n;
+        if (num > 0 && num < 32 && tm.mday < 0) {
+            tm.mday = num;
+            return n;
+        }
+        if (n === 2 && tm.year < 0) {
+            if (num < 10 && tm.mday >= 0) {
+                tm.year = num + 100;
+                return n;
+            }
+            if (num >= 70) {
+                tm.year = num;
+                return n;
+            }
+        }
+        if (num > 0 && num < 13 && tm.mon < 0)
+            tm.mon = num - 1;
+        return n;
+    };
+    const matchAlpha = (at) => {
+        for (let i = 0; i < 12; i++) {
+            const m = matchString(at, GIT_MONTHS[i]);
+            if (m >= 3) {
+                tm.mon = i;
+                return m;
+            }
+        }
+        for (let i = 0; i < 7; i++) {
+            const m = matchString(at, GIT_WEEKDAYS[i]);
+            if (m >= 3) {
+                tm.wday = i;
+                return m;
+            }
+        }
+        for (const [name, hours, dst] of GIT_ZONES) {
+            const m = matchString(at, name);
+            if (m >= 3 || m === name.length) {
+                if (offset === null)
+                    offset = 60 * (hours + dst);
+                return m;
+            }
+        }
+        if (matchString(at, 'PM') === 2) {
+            tm.hour = (tm.hour % 12) + 12;
+            return 2;
+        }
+        if (matchString(at, 'AM') === 2) {
+            tm.hour = tm.hour % 12;
+            return 2;
+        }
+        // ISO 8601's 'T' before a time.
+        if (text[at] === 'T' && isDigit(text[at + 1]) && tm.hour === -1) {
+            tm.min = 0;
+            tm.sec = 0;
+            return 1;
+        }
+        let skip = 0;
+        while (isAlpha(text[at + skip]))
+            skip++;
+        return skip;
+    };
+    const matchTz = (at) => {
+        let [hour, end] = readNumber(at + 1);
+        const n = end - (at + 1);
+        let min = 0;
+        if (n === 4) {
+            min = hour % 100;
+            hour = Math.floor(hour / 100);
+        }
+        else if (n !== 2)
+            min = 99;
+        else if (text[end] === ':') {
+            [min, end] = readNumber(end + 1);
+            if (end - (at + 1) !== 5)
+                min = 99;
+        }
+        if (min < 60 && hour < 24)
+            offset = (text[at] === '-' ? -1 : 1) * (hour * 60 + min);
+        return end - at;
+    };
+    for (let at = 0; at < text.length && text[at] !== '\n';) {
+        const c = text[at];
+        let matched = 0;
+        if (isAlpha(c))
+            matched = matchAlpha(at);
+        else if (isDigit(c))
+            matched = matchDigit(at);
+        else if ((c === '-' || c === '+') && isDigit(text[at + 1]))
+            matched = matchTz(at);
+        at += matched || 1;
+    }
+    let seconds = toTime(tm);
+    if (seconds === null)
+        return null;
+    let minutesEast;
+    if (offset === null) {
+        // No zone given: the local one at that time, as mktime() reads the same fields.
+        const local = new Date(tm.year + 1900, tm.mon, tm.mday, tm.hour, tm.min, tm.sec).getTime() / 1000;
+        minutesEast = Math.round((seconds - local) / 60);
+    }
+    else
+        minutesEast = offset;
+    if (!gmt)
+        seconds -= minutesEast * 60;
+    return { seconds, zone: gitTimezone(minutesEast) };
+}
+/**
+ * The author or committer identity git stamps an object with (ident.c):
+ * GIT_<ROLE>_NAME and GIT_<ROLE>_EMAIL, else user.name and user.email from
+ * the config, then the login name; and GIT_<ROLE>_DATE read by
+ * parseGitDate, or now. A date git cannot read is its error.
+ */
+async function gitIdent(ctx, git, fs, dir, role) {
+    const config = async (key) => {
+        try {
+            const value = await git.getConfig({ fs, dir, path: key });
+            return typeof value === 'string' ? value : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const name = ctx.env[`GIT_${role}_NAME`] || await config('user.name') || ctx.env.USER || 'user';
+    const email = ctx.env[`GIT_${role}_EMAIL`] || await config('user.email') || 'user@nimbus.dev';
+    const raw = ctx.env[`GIT_${role}_DATE`];
+    let seconds;
+    let minutesEast;
+    if (raw) {
+        const parsed = parseGitDate(raw);
+        if (!parsed)
+            return { error: `fatal: invalid date format: ${raw}\n` };
+        seconds = parsed.seconds;
+        const zone = /^([+-])(\d{2})(\d{2})$/.exec(parsed.zone);
+        minutesEast = (zone[1] === '-' ? -1 : 1) * (Number(zone[2]) * 60 + Number(zone[3]));
+    }
+    else {
+        seconds = Math.floor(Date.now() / 1000);
+        minutesEast = -new Date(seconds * 1000).getTimezoneOffset();
+    }
+    // Not -0: cf-git writes a negative zero offset as -0000, which is git's "zone unknown".
+    return { name, email, timestamp: seconds, timezoneOffset: minutesEast === 0 ? 0 : -minutesEast };
+}
+/** An identity as a signature line: `Name <email> <seconds> ±hhmm`. */
+function identLine(ident) {
+    return `${ident.name} <${ident.email}> ${ident.timestamp} ${gitTimezone(-ident.timezoneOffset)}`;
+}
+/** Both identities a commit takes, or git's error for a date it cannot read. */
+async function commitIdents(ctx, git, fs, dir) {
+    const author = await gitIdent(ctx, git, fs, dir, 'AUTHOR');
+    if ('error' in author)
+        return author;
+    const committer = await gitIdent(ctx, git, fs, dir, 'COMMITTER');
+    if ('error' in committer)
+        return committer;
+    return { author, committer };
+}
+/**
+ * git's stripspace (strbuf_stripspace): trailing whitespace, runs of blank
+ * lines and blank lines at either end go, and with `stripComments` (the
+ * `strip` cleanup, the default for a tag message) lines starting with the
+ * comment character too. A non-empty result ends with a newline.
+ */
+function cleanupMessage(text, stripComments = true) {
+    const lines = text.split('\n').filter((line) => !stripComments || !line.startsWith('#')).map((line) => line.replace(/\s+$/, ''));
+    const out = [];
+    for (const line of lines) {
+        if (line === '' && (out.length === 0 || out[out.length - 1] === ''))
+            continue;
+        out.push(line);
+    }
+    while (out.length > 0 && out[out.length - 1] === '')
+        out.pop();
+    return out.length ? `${out.join('\n')}\n` : '';
+}
+/**
+ * Commit the index with exactly `message`, git's cleanup already applied:
+ * one object, written byte for byte (the tracked cf-git patch's rawMessage;
+ * cf-git's own rendering would normalize the newlines of a verbatim message
+ * and refuse an empty one), and the branch, or a detached HEAD, moved by
+ * cf-git.
+ */
+async function writeCommit(git, fs, dir, message, idents) {
+    return git.commit({ fs, dir, message, ...idents, rawMessage: true });
+}
+/** A tag pattern (fnmatch: `*`, `?`, `[...]`) as a whole-name regular expression. */
+function tagPattern(pattern) {
+    let source = '';
+    for (const ch of pattern) {
+        source += ch === '*' ? '.*' : ch === '?' ? '.' : ch === '[' || ch === ']' ? ch : ch.replace(/[.*+?^${}()|\\/]/g, '\\$&');
+    }
+    return new RegExp(`^${source}$`);
+}
+/**
+ * `git tag`: list (-l, patterns, -n<num> with each tag's message or its
+ * commit's subject), create (lightweight, or annotated with -a, -m or -F,
+ * a tag object as git writes it), replace (-f) and delete (-d), with git's
+ * messages and exit codes.
+ */
+async function tagCommand(ctx, git, fs, vfs, args) {
+    let annotate = false;
+    let force = false;
+    let del = false;
+    let list = false;
+    let lines = null;
+    const messages = [];
+    let messageFile = null;
+    const operands = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--') {
+            operands.push(...args.slice(i + 1));
+            break;
+        }
+        if (arg === '-' || !arg.startsWith('-')) {
+            operands.push(arg);
+            continue;
+        }
+        if (arg === '--annotate') {
+            annotate = true;
+            continue;
+        }
+        if (arg === '--force') {
+            force = true;
+            continue;
+        }
+        if (arg === '--delete') {
+            del = true;
+            continue;
+        }
+        if (arg === '--list') {
+            list = true;
+            continue;
+        }
+        if (arg.startsWith('--message=')) {
+            messages.push(arg.slice('--message='.length));
+            continue;
+        }
+        if (arg === '--message') {
+            messages.push(args[++i] ?? '');
+            continue;
+        }
+        if (arg.startsWith('--file=')) {
+            messageFile = arg.slice('--file='.length);
+            continue;
+        }
+        if (arg === '--file') {
+            messageFile = args[++i] ?? '';
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            await ctx.stderr.write(`error: unknown option \`${arg.slice(2)}'\n${TAG_USAGE}`);
+            return 129;
+        }
+        for (let j = 1; j < arg.length; j++) {
+            const flag = arg[j];
+            if (flag === 'a')
+                annotate = true;
+            else if (flag === 'f')
+                force = true;
+            else if (flag === 'd')
+                del = true;
+            else if (flag === 'l')
+                list = true;
+            else if (flag === 'n') {
+                const digits = /^\d*/.exec(arg.slice(j + 1))?.[0] ?? '';
+                lines = digits ? Number(digits) : 1;
+                j += digits.length;
+            }
+            else if (flag === 'm' || flag === 'F') {
+                const value = arg.slice(j + 1) || args[++i];
+                if (value === undefined) {
+                    await ctx.stderr.write(`error: switch \`${flag}' requires a value\n${TAG_USAGE}`);
+                    return 129;
+                }
+                if (flag === 'm')
+                    messages.push(value);
+                else
+                    messageFile = value;
+                break;
+            }
+            else {
+                await ctx.stderr.write(`error: unknown switch \`${flag}'\n${TAG_USAGE}`);
+                return 129;
+            }
+        }
+    }
+    const repo = discoverRepo(vfs, ctx.cwd);
+    if (!repo) {
+        await ctx.stderr.write(NOT_A_REPOSITORY);
+        return 128;
+    }
+    const { gitdir } = repo;
+    const dir = repo.worktree ?? ctx.cwd;
+    const cache = {};
+    const abbrev = (oid) => oid.slice(0, 7);
+    if (del) {
+        let code = 0;
+        for (const name of operands) {
+            let oid;
+            try {
+                oid = await git.resolveRef({ fs, gitdir, ref: `refs/tags/${name}` });
+            }
+            catch {
+                await ctx.stderr.write(`error: tag '${name}' not found.\n`);
+                code = 1;
+                continue;
+            }
+            await git.deleteTag({ fs, dir, ref: name });
+            await ctx.stdout.write(`Deleted tag '${name}' (was ${abbrev(oid)})\n`);
+        }
+        return code;
+    }
+    const creating = !list && lines === null && operands.length > 0;
+    if (!creating) {
+        const patterns = operands.map(tagPattern);
+        const names = (await git.listTags({ fs, dir }))
+            .filter((name) => patterns.length === 0 || patterns.some((pattern) => pattern.test(name)))
+            .sort(comparePaths);
+        let out = '';
+        for (const name of names) {
+            if (lines === null) {
+                out += `${name}\n`;
+                continue;
+            }
+            // The tag's own message, or for a lightweight tag its commit's (a tree or blob has none).
+            let text = '';
+            try {
+                const oid = await git.resolveRef({ fs, gitdir, ref: `refs/tags/${name}` });
+                // The raw object, split at its first blank line as git splits it: cf-git's
+                // parsed form normalizes newlines first and misreads an empty message.
+                const { type, object } = await git.readObject({ fs, dir, oid, cache, format: 'content' });
+                if (type === 'tag' || type === 'commit') {
+                    const raw = dec.decode(object);
+                    const blank = raw.indexOf('\n\n');
+                    text = blank < 0 ? '' : raw.slice(blank + 2).split('\n-----BEGIN PGP SIGNATURE-----')[0];
+                }
+            }
+            catch { /* a broken ref lists bare */ }
+            // The first <num> lines as they are, blank ones too, continuation lines indented.
+            const shown = text.replace(/\n+$/, '').split('\n').slice(0, lines).map((line, i) => (i === 0 ? line : `    ${line}`));
+            out += shown.length && lines > 0 ? `${name.padEnd(15)} ${shown.join('\n')}\n` : `${name}\n`;
+        }
+        await writeBinary(ctx.stdout, out);
+        return 0;
+    }
+    const [name, target = 'HEAD', ...extra] = operands;
+    if (extra.length > 0) {
+        await ctx.stderr.write(`error: too many arguments\n${TAG_USAGE}`);
+        return 129;
+    }
+    if (messageFile !== null) {
+        try {
+            messages.push(dec.decode(vfs.readFile(normalizeVfsPath(messageFile.startsWith('/') ? messageFile : `${ctx.cwd}/${messageFile}`))));
+        }
+        catch {
+            await ctx.stderr.write(`fatal: could not open or read '${messageFile}': No such file or directory\n`);
+            return 128;
+        }
+    }
+    if (annotate && messages.length === 0) {
+        // git would open an editor, and this git has none: what git says with no editor to run.
+        await ctx.stderr.write('error: Terminal is dumb, but EDITOR unset\nPlease supply the message using either -m or -F option.\n');
+        return 1;
+    }
+    const object = await resolveRevision(git, fs, gitdir, target, cache);
+    if (!object) {
+        await ctx.stderr.write(`fatal: Failed to resolve '${target}' as a valid ref.\n`);
+        return 128;
+    }
+    let previous = null;
+    try {
+        previous = await git.resolveRef({ fs, gitdir, ref: `refs/tags/${name}` });
+    }
+    catch { /* new */ }
+    if (previous !== null && !force) {
+        await ctx.stderr.write(`fatal: tag '${name}' already exists\n`);
+        return 128;
+    }
+    let value;
+    if (messages.length > 0) {
+        const ident = await gitIdent(ctx, git, fs, dir, 'COMMITTER');
+        if ('error' in ident) {
+            await ctx.stderr.write(ident.error);
+            return 128;
+        }
+        const tagger = identLine(ident);
+        // The object as git writes it, byte for byte: the headers, a blank line,
+        // then the cleaned message (nothing at all when it is empty). cf-git's
+        // annotatedTag appends a newline after the message, which an empty one
+        // must not have, and its parser then misreads the listing.
+        const { type } = await git.readObject({ fs, dir, oid: object, cache: {}, format: 'parsed' });
+        const body = `object ${object}\ntype ${type}\ntag ${name}\ntagger ${tagger}\n\n${cleanupMessage(messages.join('\n\n'))}`;
+        value = await git.writeObject({ fs, dir, type: 'tag', object: new TextEncoder().encode(body), format: 'content' });
+        await git.writeRef({ fs, dir, ref: `refs/tags/${name}`, value, force: true });
+    }
+    else {
+        await git.tag({ fs, dir, ref: name, object, force: true });
+        value = object;
+    }
+    if (previous !== null && previous !== value)
+        await ctx.stdout.write(`Updated tag '${name}' (was ${abbrev(previous)})\n`);
+    return 0;
+}
+const LS_FILES_USAGE = 'usage: git ls-files [-c | --cached] [-o | --others] [-m | --modified] [-d | --deleted] '
+    + '[--exclude-standard] [-z] [--] [<path>...]\n';
+async function lsFiles(ctx, git, fs, vfs, args) {
+    let cached = false;
+    let others = false;
+    let modified = false;
+    let deleted = false;
+    let excludeStandard = false;
+    let z = false;
+    let dashdash = false;
+    const pathArgs = [];
+    for (const arg of args) {
+        if (dashdash || arg === '-' || !arg.startsWith('-')) {
+            pathArgs.push(arg);
+            continue;
+        }
+        if (arg === '--') {
+            dashdash = true;
+            continue;
+        }
+        for (const flag of arg.startsWith('--') ? [arg] : [...arg.slice(1)].map((c) => `-${c}`)) {
+            switch (flag) {
+                case '-c':
+                case '--cached':
+                    cached = true;
+                    break;
+                case '-o':
+                case '--others':
+                    others = true;
+                    break;
+                case '-m':
+                case '--modified':
+                    modified = true;
+                    break;
+                case '-d':
+                case '--deleted':
+                    deleted = true;
+                    break;
+                case '-z':
+                    z = true;
+                    break;
+                case '--exclude-standard':
+                    excludeStandard = true;
+                    break;
+                default:
+                    await ctx.stderr.write(`error: unknown option '${flag.replace(/^-+/, '')}'\n${LS_FILES_USAGE}`);
+                    return 129;
+            }
+        }
+    }
+    // With no selection ls-files shows the index.
+    if (!others && !modified && !deleted)
+        cached = true;
+    const repo = discoverRepo(vfs, ctx.cwd);
+    if (!repo) {
+        await ctx.stderr.write(NOT_A_REPOSITORY);
+        return 128;
+    }
+    const root = repo.worktree;
+    if (!root) {
+        await ctx.stderr.write(NOT_A_WORK_TREE);
+        return 128;
+    }
+    // Without pathspecs ls-files covers the cwd's subtree.
+    const specs = pathArgs.length ? repoPaths(pathArgs, ctx.cwd, root) : [repo.prefix];
+    const readWorktree = others || modified || deleted;
+    const untracked = [];
+    const tracked = [];
+    const trees = readWorktree ? [git.STAGE(), git.WORKDIR()] : [git.STAGE()];
+    const filemode = modified && await trustsFileMode(git, fs, root);
+    await walkScoped(git, fs, root, {}, trees, specs, async (path, [stage, work]) => {
+        const workType = work ? await work.type() : undefined;
+        if (stage) {
+            const stageType = await stage.type();
+            if (stageType === 'tree') {
+                // A file or link where the index has a directory is untracked; the directory's files are deleted.
+                if (others && workType && workType !== 'tree'
+                    && !(excludeStandard && await git.isIgnored({ fs, dir: root, filepath: path })))
+                    untracked.push(path);
+                return true;
+            }
+            const missing = readWorktree && !workType;
+            let changed = missing;
+            if (modified && !missing && stageType === 'blob') {
+                const stageMode = await stage.mode();
+                changed = !work || workType !== 'blob' || await work.oid() !== await stage.oid()
+                    || worktreeMode(await work.mode(), stageMode, filemode) !== stageMode;
+            }
+            tracked.push({ path, deleted: missing, modified: changed });
+            // A file replaced by a directory leaves that directory untracked.
+            return others && stageType === 'blob' && workType === 'tree';
+        }
+        if (!others || !workType)
+            return false;
+        const isDir = workType === 'tree';
+        if (excludeStandard && await git.isIgnored({ fs, dir: root, filepath: isDir ? `${path}/` : path }))
+            return false;
+        if (!isDir) {
+            untracked.push(path);
+            return false;
+        }
+        // A nested repository is listed as the directory, never entered.
+        if (!vfs.exists(normalizeVfsPath(`${root}/${path}/.git`)))
+            return true;
+        untracked.push(`${path}/`);
+        return false;
+    });
+    let out = '';
+    for (const path of untracked.sort(comparePaths))
+        out += pathLine(relativeTo(path, repo.prefix), z);
+    for (const entry of tracked.sort((a, b) => comparePaths(a.path, b.path))) {
+        const line = pathLine(relativeTo(entry.path, repo.prefix), z);
+        if (cached)
+            out += line;
+        if (deleted && entry.deleted)
+            out += line;
+        if (modified && entry.modified)
+            out += line;
+    }
+    await writeBinary(ctx.stdout, out);
+    return 0;
+}
+/**
+ * The index entries that restoring `restored` replaces (add_index_entry_with_check):
+ * a file at one of a restored path's leading directories, or anything below a
+ * restored path.
+ */
+export function replacedIndexEntries(index, restored) {
+    // Every leading directory of a restored path, once: an entry there is a file in its way.
+    const leading = new Set();
+    for (const path of restored) {
+        for (let at = path.indexOf('/'); at >= 0; at = path.indexOf('/', at + 1))
+            leading.add(path.slice(0, at));
+    }
+    return index.filter((path) => {
+        if (restored.has(path))
+            return false;
+        if (leading.has(path))
+            return true;
+        for (let at = path.indexOf('/'); at >= 0; at = path.indexOf('/', at + 1)) {
+            if (restored.has(path.slice(0, at)))
+                return true;
+        }
+        return false;
+    });
+}
+/**
+ * A checkout cf-git refused, as git reports one: its message on stderr, exit 1. A merge
+ * that is not a fast-forward (`strategy`) refuses as its strategy does, with that line
+ * after it and exit 2. Anything else propagates.
+ */
+async function refusal(ctx, error, strategy) {
+    if (!(error instanceof Error) || !('code' in error) || error.code !== 'CheckoutConflictError')
+        throw error;
+    await ctx.stderr.write(`${error.message}\n${strategy ? `Merge with strategy ${strategy} failed.\n` : ''}`);
+    return strategy ? 2 : 1;
+}
+/**
+ * `git checkout [<tree-ish>] -- <pathspec>...`: every tracked file the
+ * pathspecs name, from the index, or from <tree-ish> into the index as well
+ * (overlay mode: a path the tree lacks stays). A pathspec naming nothing fails
+ * the command before any file is written, as in git. The files are written as
+ * git's checkout writes them: see createGitFs's worktree rule.
+ */
+async function checkoutPaths(ctx, git, vfs, source, pathArgs) {
+    const repo = discoverRepo(vfs, ctx.cwd);
+    if (!repo) {
+        await ctx.stderr.write(NOT_A_REPOSITORY);
+        return 128;
+    }
+    const root = repo.worktree;
+    if (!root) {
+        await ctx.stderr.write(NOT_A_WORK_TREE);
+        return 128;
+    }
+    const specs = repoPaths(pathArgs, ctx.cwd, root);
+    // A pathspec ending in '/' names a directory: it matches what is below it, never a file or link there.
+    const dirOnly = pathArgs.map((arg, i) => arg.endsWith('/') && specs[i] !== '');
+    const fs = createGitFs(vfs, root);
+    const cache = {};
+    let tree = git.STAGE();
+    if (source !== null) {
+        const oid = await resolveRevision(git, fs, repo.gitdir, source, cache);
+        if (!oid) {
+            await ctx.stderr.write(`fatal: invalid reference: ${source}\n`);
+            return 128;
+        }
+        tree = git.TREE({ ref: oid });
+    }
+    const files = [];
+    const matched = new Set();
+    await walkScoped(git, fs, root, cache, [tree], specs, async (path, [entry]) => {
+        const type = entry ? await entry.type() : undefined;
+        if (type === 'tree')
+            return true;
+        // A gitlink is never checked out.
+        if (!entry || type !== 'blob')
+            return false;
+        const matching = specs.flatMap((spec, i) => spec === '' || path.startsWith(`${spec}/`) || (path === spec && !dirOnly[i]) ? [i] : []);
+        if (matching.length === 0)
+            return false;
+        for (const i of matching)
+            matched.add(i);
+        files.push({ path, oid: await entry.oid(), mode: await entry.mode() });
+        return false;
+    });
+    let unmatched = '';
+    pathArgs.forEach((arg, i) => {
+        if (!matched.has(i))
+            unmatched += `error: pathspec '${arg}' did not match any file(s) known to git\n`;
+    });
+    if (unmatched) {
+        await ctx.stderr.write(unmatched);
+        return 1;
+    }
+    for (const { path, oid, mode } of files) {
+        const file = `${root}/${path}`;
+        const { blob } = await git.readBlob({ fs, dir: root, oid, cache });
+        if (mode === 0o120000) {
+            await fs.promises.symlink(dec.decode(blob), file);
+        }
+        else {
+            await fs.promises.writeFile(file, blob);
+            vfs.chmod(normalizeVfsPath(file), mode === 0o100755 ? 0o755 : 0o644);
+        }
+    }
+    // The index takes each file's fresh stat data (and, from a tree, its blob). An entry a
+    // restored path replaces goes first, as add_index_entry_with_check replaces it: a file at
+    // one of its leading directories, or anything below it.
+    const restored = new Set(files.map(({ path }) => path));
+    const replaced = replacedIndexEntries(await git.listFiles({ fs, dir: root, cache }), restored);
+    if (replaced.length)
+        await git.remove({ fs, dir: root, filepath: replaced, cache });
+    if (files.length)
+        await git.add({ fs, dir: root, filepath: [...restored], parallel: false, force: true, cache });
+    return 0;
+}
+/** diff-files, diff-index and diff-index --cached, as file pairs in path order. */
+async function changedPairs(git, fs, dir, cache, base, specs) {
+    const pairs = [];
+    const filemode = await trustsFileMode(git, fs, dir);
+    // A worktree side is read against its index entry's mode.
+    const blob = async (path, entry, index) => {
+        if (!entry || (await entry.type()) !== 'blob')
+            return null;
+        const mode = await entry.mode();
+        return index
+            ? { path, oid: await entry.oid(), mode: worktreeMode(mode, await index.mode(), filemode), worktree: true }
+            : { path, oid: await entry.oid(), mode, worktree: false };
+    };
+    const record = (one, two) => {
+        if (!one && !two)
+            return;
+        if (one && two && one.oid === two.oid && one.mode === two.mode)
+            return;
+        pairs.push({ one, two });
+    };
+    const trees = base.kind === 'index'
+        ? [git.STAGE(), git.WORKDIR()]
+        : base.cached ? [git.TREE({ ref: base.ref }), git.STAGE()] : [git.TREE({ ref: base.ref }), git.STAGE(), git.WORKDIR()];
+    await walkScoped(git, fs, dir, cache, trees, specs, async (path, entries) => {
+        if (base.kind === 'index') {
+            const [stage, work] = entries;
+            const stageType = stage ? await stage.type() : undefined;
+            if (stageType !== 'blob')
+                return stageType === 'tree';
+            // A missing file, or a directory where the file was, is a deletion.
+            record(await blob(path, stage), await blob(path, work, stage));
+            return false;
+        }
+        const [head, stage, work] = entries;
+        const headType = head ? await head.type() : undefined;
+        const stageType = stage ? await stage.type() : undefined;
+        // diff-index: a path the index lacks is deleted whatever the worktree holds.
+        const two = stageType !== 'blob' ? null : base.cached ? await blob(path, stage) : await blob(path, work, stage);
+        record(await blob(path, head), two);
+        return headType === 'tree' || stageType === 'tree';
+    });
+    const pathOf = (pair) => (pair.one ?? pair.two).path;
+    return pairs.sort((a, b) => comparePaths(pathOf(a), pathOf(b)));
+}
+/** Print pairs one at a time, each loaded only while it is rendered. */
+async function writeDiff(ctx, pairs, output) {
+    const stats = [];
+    let out = '';
+    for (const load of pairs) {
+        const pair = await load();
+        if (output.format === 'stat')
+            stats.push(statFile(pair));
+        else if (output.format === 'name-only')
+            out += formatNameOnly(pair, output.z);
+        else if (output.format === 'name-status')
+            out += formatNameStatus(pair, output.z);
+        else
+            out += formatPatch(pair, output.context);
+        if (out.length >= 1 << 16) {
+            await writeBinary(ctx.stdout, out);
+            out = '';
+        }
+    }
+    if (output.format === 'stat')
+        out += formatStat(stats, output.columns);
+    await writeBinary(ctx.stdout, out);
+}
+/** `git diff --no-index`: two paths, either of them /dev/null; exits 1 when they differ. */
+async function diffNoIndex(ctx, git, vfs, paths, output) {
+    if (paths.length !== 2) {
+        await ctx.stderr.write('usage: git diff --no-index [<options>] <path> <path>\n');
+        return 129;
+    }
+    const key = (path) => normalizeVfsPath(path.startsWith('/') ? path : `${ctx.cwd}/${path}`);
+    const isDir = paths.map((path) => path !== '/dev/null' && vfs.isDirectory(key(path)));
+    if (isDir[0] && isDir[1]) {
+        await ctx.stderr.write('error: --no-index between two directories is not supported\n');
+        return 129;
+    }
+    // fixup_paths: a directory against a file means that file's namesake inside it.
+    if (isDir[0] !== isDir[1]) {
+        const dirSide = isDir[0] ? 0 : 1;
+        const file = paths[1 - dirSide];
+        paths[dirSide] = `${paths[dirSide].replace(/\/+$/, '')}/${file.slice(file.lastIndexOf('/') + 1)}`;
+    }
+    const specs = [];
+    for (const path of paths) {
+        if (path === '/dev/null') {
+            specs.push(absentSpec(path));
+            continue;
+        }
+        let st;
+        try {
+            st = vfs.lstat(key(path));
+        }
+        catch {
+            await ctx.stderr.write(`error: Could not access '${path}'\n`);
+            return 1;
+        }
+        const link = st.type === 'symlink';
+        const data = link ? enc.encode(vfs.readlink(key(path))) : vfs.readFile(key(path));
+        const { oid } = await git.hashBlob({ object: data });
+        // canon_mode: the owner's execute bit alone decides 100755.
+        const mode = link ? 0o120000 : st.mode & 0o100 ? 0o100755 : 0o100644;
+        specs.push({ path, valid: true, oid, mode, data });
+    }
+    const [one, two] = specs;
+    if (!one.valid && !two.valid)
+        return 0;
+    if (one.valid && two.valid && one.oid === two.oid && one.mode === two.mode)
+        return 0;
+    await writeDiff(ctx, [async () => ({ one, two })], output);
+    return 1;
+}
+const DIFF_USAGE = 'usage: git diff [--cached] [<commit>] [--] [<path>...]\n'
+    + '   or: git diff --no-index [--] <path> <path>\n'
+    + 'options: --stat | --name-only | --name-status, -z, -U<n>, -M[<n>] | --no-renames\n';
+async function diffCommand(ctx, git, fs, vfs, args) {
+    let cached = false;
+    let noIndex = false;
+    let dashdash = false;
+    // Renames are on by default, as with git's diff.renames; null turns them off.
+    let minimumScore = DEFAULT_RENAME_SCORE;
+    const output = {
+        format: 'patch',
+        z: false,
+        context: DEFAULT_CONTEXT,
+        columns: parseInt(ctx.env.COLUMNS ?? '', 10) > 0 ? parseInt(ctx.env.COLUMNS, 10) : 80,
+    };
+    const positionals = [];
+    const pathArgs = [];
+    for (const arg of args) {
+        if (dashdash) {
+            pathArgs.push(arg);
+            continue;
+        }
+        if (arg === '--') {
+            dashdash = true;
+            continue;
+        }
+        if (arg === '-' || !arg.startsWith('-')) {
+            positionals.push(arg);
+            continue;
+        }
+        const context = /^(?:-U|--unified=)(\d+)$/.exec(arg);
+        if (context) {
+            output.context = Number(context[1]);
+            continue;
+        }
+        const findRenames = /^(?:-M|--find-renames(?:=|$))(.*)$/.exec(arg);
+        if (findRenames) {
+            const score = parseRenameScore(findRenames[1]);
+            if (score === null) {
+                await ctx.stderr.write(`error: invalid argument to find-renames\n${DIFF_USAGE}`);
+                return 129;
+            }
+            minimumScore = score || DEFAULT_RENAME_SCORE;
+            continue;
+        }
+        switch (arg) {
+            case '--cached':
+            case '--staged':
+                cached = true;
+                continue;
+            case '--no-index':
+                noIndex = true;
+                continue;
+            case '-z':
+                output.z = true;
+                continue;
+            case '--no-renames':
+                minimumScore = null;
+                continue;
+            // A patch is the default, and nothing here colors or runs external tools.
+            case '-p':
+            case '-u':
+            case '--patch':
+            case '--no-ext-diff':
+            case '--no-color': continue;
+            case '--stat':
+            case '--name-only':
+            case '--name-status': {
+                const format = arg.slice(2);
+                if (output.format !== 'patch' && output.format !== format) {
+                    await ctx.stderr.write(`fatal: options '--${output.format}' and '${arg}' cannot be used together\n`);
+                    return 128;
+                }
+                output.format = format;
+                continue;
+            }
+        }
+        await ctx.stderr.write(`error: unknown option '${arg.replace(/^-+/, '')}'\n${DIFF_USAGE}`);
+        return 129;
+    }
+    if (noIndex) {
+        if (cached) {
+            await ctx.stderr.write("fatal: options '--cached' and '--no-index' cannot be used together\n");
+            return 128;
+        }
+        return diffNoIndex(ctx, git, vfs, [...positionals, ...pathArgs], output);
+    }
+    const repo = discoverRepo(vfs, ctx.cwd);
+    if (!repo) {
+        await ctx.stderr.write(NOT_A_REPOSITORY);
+        return 128;
+    }
+    const root = repo.worktree;
+    if (!root) {
+        await ctx.stderr.write(NOT_A_WORK_TREE);
+        return 128;
+    }
+    const cache = {};
+    const revs = [];
+    for (const arg of positionals) {
+        // Before `--` a word is a revision until one is not; then it and the rest must be paths.
+        const oid = pathArgs.length && !dashdash ? null : await resolveRevision(git, fs, repo.gitdir, arg, cache);
+        if (oid !== null) {
+            revs.push(oid);
+            continue;
+        }
+        if (dashdash) {
+            await ctx.stderr.write(`fatal: bad revision '${arg}'\n`);
+            return 128;
+        }
+        if (!vfs.exists(normalizeVfsPath(arg.startsWith('/') ? arg : `${ctx.cwd}/${arg}`))) {
+            await ctx.stderr.write(ambiguousArgument(arg));
+            return 128;
+        }
+        pathArgs.push(arg);
+    }
+    if (revs.length > 1) {
+        await ctx.stderr.write('fatal: diff between two commits is not supported; compare one commit with the worktree or the index\n');
+        return 128;
+    }
+    const base = cached
+        ? { kind: 'tree', ref: revs[0] ?? 'HEAD', cached: true }
+        : revs.length ? { kind: 'tree', ref: revs[0], cached: false } : { kind: 'index' };
+    const pending = await changedPairs(git, fs, root, cache, base, repoPaths(pathArgs, ctx.cwd, root));
+    const read = async (side) => {
+        if (!side.worktree)
+            return (await git.readBlob({ fs, dir: root, oid: side.oid, cache })).blob;
+        const key = normalizeVfsPath(`${root}/${side.path}`);
+        return side.mode === 0o120000 ? enc.encode(vfs.readlink(key)) : vfs.readFile(key);
+    };
+    const { queue, neededRenameLimit } = minimumScore === null
+        ? { queue: pending, neededRenameLimit: 0 }
+        : await detectRenames(pending, read, { minimumScore });
+    const withData = output.format === 'patch' || output.format === 'stat';
+    const spec = async (side) => ({
+        path: side.path,
+        valid: true,
+        oid: side.oid,
+        mode: side.mode,
+        data: withData ? await read(side) : new Uint8Array(0),
+    });
+    await writeDiff(ctx, queue.map(({ one, two, renameScore }) => async () => ({
+        one: one ? await spec(one) : absentSpec(two.path),
+        two: two ? await spec(two) : absentSpec(one.path),
+        renameScore,
+    })), output);
+    if (neededRenameLimit) {
+        await ctx.stderr.write('warning: exhaustive rename detection was skipped due to too many files.\n'
+            + `warning: you may want to set your diff.renameLimit variable to at least ${neededRenameLimit} and retry the command.\n`);
+    }
+    return 0;
 }
 // ── Git subcommand implementations ──────────────────────────────────────
 /**
@@ -254,10 +1905,18 @@ function getAuthor(ctx) {
 export async function runGitCommand(ctx, vfs, doCtx, doEnv) {
     const credentialedVfs = vfs.as(requireVfsCred(ctx.cred, 'git'));
     const fs = createGitFs(credentialedVfs);
-    const args = ctx.args;
-    const sub = args[0];
-    const subArgs = args.slice(1);
-    const dir = getDir(ctx);
+    let globals;
+    try {
+        globals = parseGitGlobals(ctx.args, getDir(ctx));
+    }
+    catch (e) {
+        ctx.stderr.write(`git: ${e?.message}\n`);
+        return 129;
+    }
+    const { sub, subArgs, dir } = globals;
+    // Every subcommand below reads `dir` and the clone's `getDir(ctx)`; `-C`
+    // moves both, exactly as `git -C <path>` runs the command from <path>.
+    ctx = { ...ctx, cwd: dir };
     if (sub === '--version' || sub === '-v') {
         ctx.stdout.write('git version 2.44.0 (isomorphic-git/cf-git)\n');
         return 0;
@@ -266,8 +1925,8 @@ export async function runGitCommand(ctx, vfs, doCtx, doEnv) {
         ctx.stdout.write('usage: git <command> [<args>]\n\n');
         ctx.stdout.write('Commands:\n');
         ctx.stdout.write('  init, clone, status, add, commit, log, branch,\n');
-        ctx.stdout.write('  checkout, diff, remote, fetch, pull, push, merge,\n');
-        ctx.stdout.write('  reset, tag, config, --version\n');
+        ctx.stdout.write('  checkout, diff, ls-files, rev-parse, remote,\n');
+        ctx.stdout.write('  fetch, pull, push, merge, reset, tag, config, --version\n');
         return 0;
     }
     // Lazy-load isomorphic-git only when actually needed.
@@ -295,11 +1954,14 @@ export async function runGitCommand(ctx, vfs, doCtx, doEnv) {
                         credentialedVfs.mkdir(stripped, { recursive: true });
                 }
                 await git.init({ fs, dir: initDir });
-                ctx.stdout.write(`Initialized empty Git repository in ${initDir}/.git/\n`);
+                if (!subArgs.includes('-q') && !subArgs.includes('--quiet')) {
+                    ctx.stdout.write(`Initialized empty Git repository in ${initDir}/.git/\n`);
+                }
                 return 0;
             }
             case 'clone': {
-                const { url, dest: destArg, depth, isBg, branch } = parseCloneArgs(subArgs);
+                const { url, dest: destArg, depth, isBg, branch, quiet } = parseCloneArgs(subArgs);
+                const progress = quiet ? { write() { } } : ctx.stdout;
                 if (!url) {
                     ctx.stderr.write(CLONE_USAGE + '\n');
                     return 1;
@@ -322,7 +1984,7 @@ export async function runGitCommand(ctx, vfs, doCtx, doEnv) {
                     ctx.stderr.write('[git] clone requires DO ctx + env (internal configuration error)\n');
                     return 1;
                 }
-                ctx.stdout.write(`Cloning into '${dest}'...${depth ? ' (shallow, depth=' + depth + ')' : ''}\n`);
+                progress.write(`Cloning into '${dest}'...${depth ? ' (shallow, depth=' + depth + ')' : ''}\n`);
                 // A clone's closed-world filesystem view is correct only while no
                 // other session surface can mutate its destination subtree. Acquire
                 // the lease before the facet performs its lstat/readdir emptiness
@@ -342,6 +2004,7 @@ export async function runGitCommand(ctx, vfs, doCtx, doEnv) {
                             url,
                             ref: branch,
                             depth,
+                            quiet,
                             exclusiveDestination: true,
                             exclusiveMutationRoot: mutationLease.root,
                             mutationOwner: mutationLease.owner,
@@ -357,7 +2020,7 @@ export async function runGitCommand(ctx, vfs, doCtx, doEnv) {
                             },
                         });
                         if (result.success) {
-                            ctx.stdout.write(`\n[git] clone complete (${result.filesWritten} files, ` +
+                            progress.write(`\n[git] clone complete (${result.filesWritten} files, ` +
                                 `${(result.bytesWritten / 1024).toFixed(1)}KB in ${(result.elapsed / 1000).toFixed(1)}s)\n`);
                         }
                         else {
@@ -372,7 +2035,7 @@ export async function runGitCommand(ctx, vfs, doCtx, doEnv) {
                 if (isBg) {
                     const task = doClone();
                     doCtx.waitUntil(task);
-                    ctx.stdout.write('[git] clone running in background...\n');
+                    progress.write('[git] clone running in background...\n');
                     return 0;
                 }
                 else {
@@ -405,41 +2068,47 @@ export async function runGitCommand(ctx, vfs, doCtx, doEnv) {
                     ctx.stdout.write('nothing to commit, working tree clean\n');
                 return 0;
             }
-            case 'add': {
-                const paths = subArgs.filter(a => !a.startsWith('-'));
-                if (paths.length === 0 || paths.includes('.')) {
-                    // Add all
-                    const matrix = await git.statusMatrix({ fs, dir });
-                    for (const [filepath, head, workdir, stage] of matrix) {
-                        if (head !== workdir || workdir !== stage) {
-                            if (workdir === 0)
-                                await git.remove({ fs, dir, filepath });
-                            else
-                                await git.add({ fs, dir, filepath });
-                        }
+            case 'add':
+                return await addCommand(ctx, git, fs, credentialedVfs, subArgs);
+            case 'commit': {
+                const { messages, quiet, all, cleanup, allowEmptyMessage } = parseCommitArgs(subArgs);
+                let configured;
+                if (cleanup === null) {
+                    try {
+                        const value = await git.getConfig({ fs, dir, path: 'commit.cleanup' });
+                        if (typeof value === 'string')
+                            configured = value;
                     }
+                    catch { /* unset */ }
                 }
-                else {
-                    for (const filepath of paths) {
-                        await git.add({ fs, dir, filepath });
-                    }
+                const requested = cleanup ?? configured;
+                const mode = commitCleanupMode(requested);
+                if (!mode) {
+                    await ctx.stderr.write(`fatal: Invalid cleanup mode ${requested}\n`);
+                    return 128;
                 }
-                return 0;
-            }
-            case 'commit': {
-                const msgIdx = subArgs.indexOf('-m');
-                const message = msgIdx >= 0 ? subArgs[msgIdx + 1] : 'commit';
-                if (!message) {
-                    ctx.stderr.write('error: empty commit message\n');
+                const raw = messages.length ? joinMessageOptions(messages) : 'commit\n';
+                const message = mode === 'verbatim' ? raw : cleanupMessage(raw, mode === 'strip');
+                if (!message && !allowEmptyMessage) {
+                    await ctx.stderr.write('Aborting commit due to empty commit message.\n');
                     return 1;
                 }
-                const sha = await git.commit({
-                    fs, dir, message,
-                    author: getAuthor(ctx),
-                });
-                ctx.stdout.write(`[${sha.slice(0, 7)}] ${message}\n`);
+                if (all)
+                    await stageTracked(git, fs, dir);
+                const idents = await commitIdents(ctx, git, fs, dir);
+                if ('error' in idents) {
+                    await ctx.stderr.write(idents.error);
+                    return 128;
+                }
+                const sha = await writeCommit(git, fs, dir, message, idents);
+                if (!quiet)
+                    ctx.stdout.write(`[${sha.slice(0, 7)}] ${message.split('\n')[0]}\n`);
                 return 0;
             }
+            case 'rev-parse':
+                return await revParse(ctx, git, fs, credentialedVfs, subArgs);
+            case 'ls-files':
+                return await lsFiles(ctx, git, fs, credentialedVfs, subArgs);
             case 'log': {
                 const maxCount = parseInt(getFlag(subArgs, '-n') || getFlag(subArgs, '--max-count') || '10');
                 const oneline = subArgs.includes('--oneline');
@@ -458,6 +2127,18 @@ export async function runGitCommand(ctx, vfs, doCtx, doEnv) {
                 return 0;
             }
             case 'branch': {
+                if (subArgs[0] === '--show-current') {
+                    // Empty output on a detached HEAD, like git.
+                    const current = await git.currentBranch({ fs, dir });
+                    if (current)
+                        ctx.stdout.write(`${current}\n`);
+                    return 0;
+                }
+                const unknown = subArgs.find((a) => a.startsWith('-') && !['-a', '--list', '-d', '-D'].includes(a));
+                if (unknown) {
+                    ctx.stderr.write(`error: unknown option '${unknown}'\nusage: git branch [-a | --list | --show-current | -d <name> | -D <name> | <name>]\n`);
+                    return 129;
+                }
                 if (subArgs.length === 0 || subArgs[0] === '-a' || subArgs[0] === '--list') {
                     const branches = await git.listBranches({ fs, dir });
                     const current = await git.currentBranch({ fs, dir });
@@ -488,47 +2169,38 @@ export async function runGitCommand(ctx, vfs, doCtx, doEnv) {
                 return 0;
             }
             case 'checkout': {
-                const ref = subArgs.find(a => !a.startsWith('-'));
+                // `--` with paths after it restores those paths; a bare `--` only ends the options.
+                const dashdash = subArgs.indexOf('--');
+                const options = dashdash >= 0 ? subArgs.slice(0, dashdash) : subArgs;
+                if (dashdash >= 0 && dashdash < subArgs.length - 1) {
+                    const source = options.find(a => !a.startsWith('-'));
+                    return await checkoutPaths(ctx, git, credentialedVfs, source ?? null, subArgs.slice(dashdash + 1));
+                }
+                const quiet = options.includes('-q') || options.includes('--quiet');
+                const ref = options.find(a => !a.startsWith('-'));
+                // `git checkout` and `git checkout HEAD` switch to where HEAD already is: nothing changes.
+                if ((!ref || ref === 'HEAD') && !options.includes('-b'))
+                    return 0;
                 if (!ref) {
-                    ctx.stderr.write('error: specify a branch\n');
-                    return 1;
+                    ctx.stderr.write("error: switch `b' requires a value\n");
+                    return 129;
                 }
-                if (subArgs.includes('-b')) {
+                const worktreeFs = createGitFs(credentialedVfs, dir);
+                const create = options.includes('-b');
+                if (create)
                     await git.branch({ fs, dir, ref });
-                    await git.checkout({ fs, dir, ref });
-                    ctx.stdout.write(`Switched to a new branch '${ref}'\n`);
-                }
-                else {
-                    await git.checkout({ fs, dir, ref });
-                    ctx.stdout.write(`Switched to branch '${ref}'\n`);
+                try {
+                    await git.checkout({ fs: worktreeFs, dir, ref });
                 }
-                return 0;
-            }
-            case 'diff': {
-                // Simple diff: show unstaged changes
-                const matrix = await git.statusMatrix({ fs, dir });
-                for (const [filepath, head, workdir, stage] of matrix) {
-                    if (workdir !== head || workdir !== stage) {
-                        ctx.stdout.write(`\x1b[1mdiff --git a/${filepath} b/${filepath}\x1b[0m\n`);
-                        try {
-                            const raw = await fs.promises.readFile(dir + '/' + filepath);
-                            const content = typeof raw === 'string' ? raw : dec.decode(raw);
-                            const lines = content.split('\n');
-                            for (let i = 0; i < Math.min(lines.length, 50); i++) {
-                                if (head === 0)
-                                    ctx.stdout.write(`\x1b[32m+${lines[i]}\x1b[0m\n`);
-                                else
-                                    ctx.stdout.write(` ${lines[i]}\n`);
-                            }
-                            if (lines.length > 50)
-                                ctx.stdout.write(`... (${lines.length - 50} more lines)\n`);
-                        }
-                        catch { }
-                        ctx.stdout.write('\n');
-                    }
+                catch (e) {
+                    return await refusal(ctx, e);
                 }
+                if (!quiet)
+                    ctx.stdout.write(create ? `Switched to a new branch '${ref}'\n` : `Switched to branch '${ref}'\n`);
                 return 0;
             }
+            case 'diff':
+                return await diffCommand(ctx, git, fs, credentialedVfs, subArgs);
             case 'remote': {
                 if (subArgs[0] === 'add' && subArgs[1] && subArgs[2]) {
                     await git.addRemote({ fs, dir, remote: subArgs[1], url: subArgs[2] });
@@ -547,24 +2219,28 @@ export async function runGitCommand(ctx, vfs, doCtx, doEnv) {
                 return 0;
             }
             case 'fetch': {
-                const remote = subArgs[0] || 'origin';
+                const { quiet, rest } = takeQuiet(subArgs);
+                const remote = rest[0] || 'origin';
                 if (!doCtx || !doEnv) {
                     ctx.stderr.write('[git] fetch requires DO ctx + env (internal configuration error)\n');
                     return 1;
                 }
-                ctx.stdout.write(`Fetching from ${remote}...\n`);
+                if (!quiet)
+                    ctx.stdout.write(`Fetching from ${remote}...\n`);
                 const result = await execGitNetwork(doCtx, doEnv, {
                     op: 'fetch',
                     pid: ctx.pid,
                     dir,
                     remote,
+                    quiet,
                     auth: {
                         username: ctx.env.GIT_USERNAME || '',
                         password: ctx.env.GIT_PASSWORD || ctx.env.GIT_TOKEN || '',
                     },
                 });
                 if (result.success) {
-                    ctx.stdout.write(`\n[git] fetch complete (${result.filesWritten} files in ${(result.elapsed / 1000).toFixed(1)}s)\n`);
+                    if (!quiet)
+                        ctx.stdout.write(`\n[git] fetch complete (${result.filesWritten} files in ${(result.elapsed / 1000).toFixed(1)}s)\n`);
                     return 0;
                 }
                 else {
@@ -573,27 +2249,36 @@ export async function runGitCommand(ctx, vfs, doCtx, doEnv) {
                 }
             }
             case 'pull': {
-                const remote = subArgs[0] || 'origin';
-                const branch = subArgs[1] || await git.currentBranch({ fs, dir }) || 'main';
+                const { quiet, rest } = takeQuiet(subArgs);
+                const remote = rest[0] || 'origin';
+                const branch = rest[1] || await git.currentBranch({ fs, dir }) || 'main';
                 if (!doCtx || !doEnv) {
                     ctx.stderr.write('[git] pull requires DO ctx + env (internal configuration error)\n');
                     return 1;
                 }
-                ctx.stdout.write(`Pulling from ${remote}/${branch}...\n`);
+                const pullIdents = await commitIdents(ctx, git, fs, dir);
+                if ('error' in pullIdents) {
+                    await ctx.stderr.write(pullIdents.error);
+                    return 128;
+                }
+                if (!quiet)
+                    ctx.stdout.write(`Pulling from ${remote}/${branch}...\n`);
                 const result = await execGitNetwork(doCtx, doEnv, {
                     op: 'pull',
                     pid: ctx.pid,
                     dir,
                     remote,
                     ref: branch,
-                    author: getAuthor(ctx),
+                    quiet,
+                    ...pullIdents,
                     auth: {
                         username: ctx.env.GIT_USERNAME || '',
                         password: ctx.env.GIT_PASSWORD || ctx.env.GIT_TOKEN || '',
                     },
                 });
                 if (result.success) {
-                    ctx.stdout.write(`\n[git] pull complete (${result.filesWritten} files in ${(result.elapsed / 1000).toFixed(1)}s)\n`);
+                    if (!quiet)
+                        ctx.stdout.write(`\n[git] pull complete (${result.filesWritten} files in ${(result.elapsed / 1000).toFixed(1)}s)\n`);
                     return 0;
                 }
                 else {
@@ -602,26 +2287,30 @@ export async function runGitCommand(ctx, vfs, doCtx, doEnv) {
                 }
             }
             case 'push': {
-                const remote = subArgs[0] || 'origin';
-                const branch = subArgs[1] || await git.currentBranch({ fs, dir }) || 'main';
+                const { quiet, rest } = takeQuiet(subArgs);
+                const remote = rest[0] || 'origin';
+                const branch = rest[1] || await git.currentBranch({ fs, dir }) || 'main';
                 if (!doCtx || !doEnv) {
                     ctx.stderr.write('[git] push requires DO ctx + env (internal configuration error)\n');
                     return 1;
                 }
-                ctx.stdout.write(`Pushing to ${remote}/${branch}...\n`);
+                if (!quiet)
+                    ctx.stdout.write(`Pushing to ${remote}/${branch}...\n`);
                 const result = await execGitNetwork(doCtx, doEnv, {
                     op: 'push',
                     pid: ctx.pid,
                     dir,
                     remote,
                     ref: branch,
+                    quiet,
                     auth: {
                         username: ctx.env.GIT_USERNAME || '',
                         password: ctx.env.GIT_PASSWORD || ctx.env.GIT_TOKEN || '',
                     },
                 });
                 if (result.success) {
-                    ctx.stdout.write(`\n[git] push complete (${(result.elapsed / 1000).toFixed(1)}s)\n`);
+                    if (!quiet)
+                        ctx.stdout.write(`\n[git] push complete (${(result.elapsed / 1000).toFixed(1)}s)\n`);
                     return 0;
                 }
                 else {
@@ -630,16 +2319,35 @@ export async function runGitCommand(ctx, vfs, doCtx, doEnv) {
                 }
             }
             case 'merge': {
-                const theirs = subArgs[0];
+                const theirs = subArgs.find(a => !a.startsWith('-'));
                 if (!theirs) {
                     ctx.stderr.write('usage: git merge <branch>\n');
                     return 1;
                 }
-                await git.merge({
-                    fs, dir, theirs,
-                    author: getAuthor(ctx),
+                // Into the current branch, or HEAD when detached. The branch moves only once the worktree
+                // and index have: a checkout git refuses ("would be overwritten by merge") changes nothing.
+                const ours = await git.currentBranch({ fs, dir, fullname: true }) ?? 'HEAD';
+                const mergeIdents = await commitIdents(ctx, git, fs, dir);
+                if ('error' in mergeIdents) {
+                    await ctx.stderr.write(mergeIdents.error);
+                    return 128;
+                }
+                const merged = await git.merge({
+                    fs, dir, ours, theirs,
+                    ...mergeIdents,
+                    noUpdateBranch: true,
                 });
-                ctx.stdout.write(`Merged ${theirs}\n`);
+                if (!merged.alreadyMerged) {
+                    try {
+                        await git.checkout({ fs: createGitFs(credentialedVfs, dir), dir, ref: merged.oid, noUpdateHead: true, conflictOperation: 'merge' });
+                    }
+                    catch (e) {
+                        return await refusal(ctx, e, merged.fastForward ? undefined : 'ort');
+                    }
+                    await git.writeRef({ fs, dir, ref: ours, value: merged.oid, force: true });
+                }
+                if (!subArgs.includes('-q') && !subArgs.includes('--quiet'))
+                    ctx.stdout.write(`Merged ${theirs}\n`);
                 return 0;
             }
             case 'reset': {
@@ -647,13 +2355,16 @@ export async function runGitCommand(ctx, vfs, doCtx, doEnv) {
                 const soft = subArgs.includes('--soft');
                 const ref = subArgs.find(a => !a.startsWith('-')) || 'HEAD';
                 const oid = await git.resolveRef({ fs, dir, ref });
-                // Move the current branch to the target OID
-                const branch = await git.currentBranch({ fs, dir });
-                if (branch) {
-                    await git.writeRef({ fs, dir, ref: `refs/heads/${branch}`, value: oid, force: true });
+                if (hard) {
+                    // The index and worktree become the target's, as a forced checkout from the old index
+                    // makes them (type changes included), before the branch moves: a failed write leaves it.
+                    await git.checkout({ fs: createGitFs(credentialedVfs, dir), dir, ref: oid, force: true, noUpdateHead: true });
                 }
-                if (!soft) {
-                    // Reset index (--mixed behavior, also applies to --hard)
+                // Move the current branch, or a detached HEAD, to the target OID
+                const branch = await git.currentBranch({ fs, dir });
+                await git.writeRef({ fs, dir, ref: branch ? `refs/heads/${branch}` : 'HEAD', value: oid, force: true });
+                if (!hard && !soft) {
+                    // Reset index (--mixed)
                     const matrix = await git.statusMatrix({ fs, dir });
                     for (const [filepath] of matrix) {
                         try {
@@ -662,31 +2373,11 @@ export async function runGitCommand(ctx, vfs, doCtx, doEnv) {
                         catch { }
                     }
                 }
-                if (hard) {
-                    // Reset working tree to match the target
-                    await git.checkout({ fs, dir, ref: oid, force: true });
-                }
                 ctx.stdout.write(`HEAD is now at ${oid.slice(0, 7)}\n`);
                 return 0;
             }
-            case 'tag': {
-                if (subArgs.length === 0) {
-                    const tags = await git.listTags({ fs, dir });
-                    for (const t of tags)
-                        ctx.stdout.write(t + '\n');
-                }
-                else if (subArgs.includes('-d')) {
-                    const name = subArgs.find(a => !a.startsWith('-'));
-                    if (name)
-                        await git.deleteTag({ fs, dir, ref: name });
-                }
-                else {
-                    const name = subArgs[0];
-                    await git.tag({ fs, dir, ref: name });
-                    ctx.stdout.write(`Created tag ${name}\n`);
-                }
-                return 0;
-            }
+            case 'tag':
+                return await tagCommand(ctx, git, fs, credentialedVfs, subArgs);
             case 'config': {
                 const key = subArgs.find(a => !a.startsWith('-'));
                 const value = subArgs[subArgs.indexOf(key || '') + 1];
@@ -717,6 +2408,9 @@ export async function runGitCommand(ctx, vfs, doCtx, doEnv) {
         }
     }
     catch (e) {
+        // The reader went away (`git diff | head`): git dies of SIGPIPE, silently.
+        if (e?.code === 'EPIPE')
+            return 141;
         ctx.stderr.write(`fatal: ${e?.message || e}\n`);
         return 128;
     }