Skip to content
zit Artifact [21bc61241f]
Login

Artifact [21bc61241f]

Artifact 21bc61241f2d3e5e42c5513f1deef1a4df9553df3823a0bfb81ebe43fe4cd44a:


const std = @import("std");
const checkout = @import("zit").checkout;
const artifact = @import("zit").artifact;
const cli = @import("zit").cli;
const File = std.Io.File;
const support = @import("support.zig");
const addManaged = support.addManaged;
const appendArtifact = support.appendArtifact;
const appendDiffManifest = support.appendDiffManifest;
const appendTagControl = support.appendTagControl;
const checkinHash = support.checkinHash;
const commitHashDup = support.commitHashDup;
const expectCheckoutVersion = support.expectCheckoutVersion;
const expectExit = support.expectExit;
const expectExitDiag = support.expectExitDiag;
const expectFileContent = support.expectFileContent;
const expectManaged = support.expectManaged;
const expectNoDiagnostic = support.expectNoDiagnostic;
const fileExists = support.fileExists;
const freeResult = support.freeResult;
const freshLoopbackPort = support.freshLoopbackPort;
const initRepo = support.initRepo;
const readFile = support.readFile;
const readManagedImage = support.readManagedImage;
const runCommitEnv = support.runCommitEnv;
const runZit = support.runZit;
const sectionExists = support.sectionExists;
const spawnServe = support.spawnServe;
const waitForListen = support.waitForListen;
const writeFile = support.writeFile;

test "cli update and stash apply --merge: adjacent edits merge cleanly" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "f", "a\nb\nc\n");
    try addManaged(gpa, io, tmp.dir, &.{"f"});
    var first = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "base" });
    defer freeResult(gpa, &first);
    try expectExit(first.term, 0);
    const older = try checkinHash(first.stdout);

    try writeFile(io, tmp.dir, "f", "a\nb\nC\n");
    var second = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "tip" });
    defer freeResult(gpa, &second);
    try expectExit(second.term, 0);
    const tip = try checkinHash(second.stdout);

    // Uncommitted work on the older check-in, next to the tip's edit.
    var back = try runZit(gpa, io, tmp.dir, &.{ "update", older });
    defer freeResult(gpa, &back);
    try expectExit(back.term, 0);
    try writeFile(io, tmp.dir, "f", "a\nB\nc\n");
    var joined = try runZit(gpa, io, tmp.dir, &.{ "update", tip });
    defer freeResult(gpa, &joined);
    try expectExitDiag(joined.term, 0, joined);
    try expectCheckoutVersion(io, tmp.dir, tip);
    try expectFileContent(gpa, io, tmp.dir, "f", "a\nB\nC\n");

    // A stashed edit folded into a dirty file next to the working edit.
    var rv = try runZit(gpa, io, tmp.dir, &.{"revert"});
    defer freeResult(gpa, &rv);
    try expectExit(rv.term, 0);
    try writeFile(io, tmp.dir, "f", "A\nb\nC\n");
    var snap = try runZit(gpa, io, tmp.dir, &.{ "stash", "snapshot", "-m", "snap" });
    defer freeResult(gpa, &snap);
    try expectExitDiag(snap.term, 0, snap);
    try writeFile(io, tmp.dir, "f", "a\nB\nC\n");
    var folded = try runZit(gpa, io, tmp.dir, &.{ "stash", "apply", "--merge" });
    defer freeResult(gpa, &folded);
    try expectExitDiag(folded.term, 0, folded);
    try expectFileContent(gpa, io, tmp.dir, "f", "A\nB\nC\n");
}

/// Writes a control artifact that flips `target`'s branch tag — the branch-only
/// wrapper the update tests already rely on.
fn appendBranchControl(
    gpa: std.mem.Allocator,
    io: std.Io,
    dir: std.Io.Dir,
    timestamp: []const u8,
    sign: artifact.TSign,
    target: []const u8,
    value: ?[]const u8,
) ![]u8 {
    return appendTagControl(gpa, io, dir, timestamp, sign, "branch", target, value);
}

// ==========================================================================
// `zit update CHECKIN` end-to-end. These tests exercise the public command
// against real check-ins and synthetic delta fixtures without reaching into
// the update implementation.
// ==========================================================================

test "cli update: a clean canonical target restores earlier content and checkout ID" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "tracked.txt", "earlier\n");
    try addManaged(gpa, io, tmp.dir, &.{"tracked.txt"});

    var root_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "earlier" });
    defer freeResult(gpa, &root_commit);
    try expectExit(root_commit.term, 0);
    const root = try checkinHash(root_commit.stdout);

    try writeFile(io, tmp.dir, "tracked.txt", "later\n");
    var child_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "later" });
    defer freeResult(gpa, &child_commit);
    try expectExit(child_commit.term, 0);

    var update = try runZit(gpa, io, tmp.dir, &.{ "update", root });
    defer freeResult(gpa, &update);
    try expectExit(update.term, 0);
    try expectNoDiagnostic(update.stderr); // the receipt lives on stderr

    const restored = try readFile(gpa, io, tmp.dir, "tracked.txt");
    defer gpa.free(restored);
    try std.testing.expectEqualStrings("earlier\n", restored);
    try expectCheckoutVersion(io, tmp.dir, root);
    try expectManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
}

test "cli update: a non-manifest target leaves the clean checkout unchanged" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "tracked.txt", "kept\n");
    try addManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
    var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "kept" });
    defer freeResult(gpa, &commit);
    try expectExit(commit.term, 0);
    const current = try checkinHash(commit.stdout);

    const non_manifest = try appendArtifact(gpa, io, tmp.dir, "not a manifest\n");
    defer gpa.free(non_manifest);
    const before_checkout = try readFile(gpa, io, tmp.dir, ".zit-checkout");
    defer gpa.free(before_checkout);
    const before_managed = try readManagedImage(gpa, io, tmp.dir);
    defer gpa.free(before_managed);
    const before_content = try readFile(gpa, io, tmp.dir, "tracked.txt");
    defer gpa.free(before_content);

    var update = try runZit(gpa, io, tmp.dir, &.{ "update", non_manifest });
    defer freeResult(gpa, &update);
    try expectExit(update.term, 1);

    const after_checkout = try readFile(gpa, io, tmp.dir, ".zit-checkout");
    defer gpa.free(after_checkout);
    const after_managed = try readManagedImage(gpa, io, tmp.dir);
    defer gpa.free(after_managed);
    const after_content = try readFile(gpa, io, tmp.dir, "tracked.txt");
    defer gpa.free(after_content);
    try std.testing.expectEqualSlices(u8, before_checkout, after_checkout);
    try std.testing.expectEqualSlices(u8, before_managed, after_managed);
    try std.testing.expectEqualSlices(u8, before_content, after_content);
    try expectCheckoutVersion(io, tmp.dir, current);
    try expectManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
}

// The shape that made `zit update` accuse an intact fossil clone of corruption:
// a store that also holds an anonymous wiki edit (cards D L W Z, no U). The
// artifact parses and is well-framed, but §5.2 requires a U card on a WIKI
// artifact, so classification declines with MissingRequiredCard; its bytes
// still hash to the name it is stored under, so the repository is undamaged and
// the artifact is opaque to state. `update` derives state over the whole log
// and so meets that artifact, exactly as `timeline`/`ls`/`info`/`branch` do.
//
// This pins the general form of the defect (Repository State erratum
// `repo-state-00-s4-unclassifiable-artifact`): no read verb may succeed on a
// store where `update` fails for a reason the reader tolerated. Pre-fix, update
// exited 1 while every read verb read the same store fine; post-fix, all agree.
test "cli update: an unclassifiable artifact in the store is tolerated, and update agrees with the read verbs" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);

    // Two real check-ins: `root` (earlier) is the update target, and a later
    // commit is the current tip, so `update root` is a genuine backward update.
    try writeFile(io, tmp.dir, "tracked.txt", "earlier\n");
    try addManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
    var root_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "earlier" });
    defer freeResult(gpa, &root_commit);
    try expectExit(root_commit.term, 0);
    const root = try checkinHash(root_commit.stdout);

    try writeFile(io, tmp.dir, "tracked.txt", "later\n");
    var child_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "later" });
    defer freeResult(gpa, &child_commit);
    try expectExit(child_commit.term, 0);

    // Inject the anonymous wiki artifact under its true hash (appendArtifact
    // names it by content), so it is unclassifiable yet undamaged.
    const wiki_body = "D 2008-11-24T02:18:26\nL RockShoxBugs\nW 12\nhello, world\n";
    var sum_buf: [32]u8 = undefined;
    const sum = artifact.selfChecksum(wiki_body, &sum_buf);
    const wiki_bytes = try std.fmt.allocPrint(gpa, "{s}Z {s}\n", .{ wiki_body, sum });
    defer gpa.free(wiki_bytes);
    const wiki_name = try appendArtifact(gpa, io, tmp.dir, wiki_bytes);
    defer gpa.free(wiki_name);

    // The fix: update tolerates the verified-but-unclassifiable artifact and
    // restores the target. Pre-fix this exited 1 (Corrupt).
    var update_res = try runZit(gpa, io, tmp.dir, &.{ "update", root });
    defer freeResult(gpa, &update_res);
    try expectExit(update_res.term, 0);
    const restored = try readFile(gpa, io, tmp.dir, "tracked.txt");
    defer gpa.free(restored);
    try std.testing.expectEqualStrings("earlier\n", restored);
    try expectCheckoutVersion(io, tmp.dir, root);

    // Read/assembly agreement: every read verb reads the same store — the one
    // update just tolerated — and must also exit 0.
    const read_verbs = [_][]const []const u8{
        &.{"timeline"},
        &.{"branch"},
        &.{ "info", root },
        &.{ "ls", root },
    };
    for (read_verbs) |argv| {
        var res = try runZit(gpa, io, tmp.dir, argv);
        defer freeResult(gpa, &res);
        try expectExit(res.term, 0);
    }
}

test "cli update: a moved tip under uncommitted work joins without forking" {
    // The issue's own reproduction, end to end. Every exit used to be closed:
    // `commit` refused with "run 'zit update' to join it", `update` refused
    // because the tree was dirty, `merge` refused for the same reason, and
    // `stash pop` cannot replay onto a check-in other than the one it was taken
    // from. The only way to keep the work was `commit --allow-fork` — so the
    // guard that exists to keep forks deliberate was manufacturing them.
    //
    // The fork guard is NOT relaxed here; it still refuses a non-leaf parent.
    // What changed is that its advice is now followable.
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "f.txt", "base\n");
    try addManaged(gpa, io, tmp.dir, &.{"f.txt"});
    var first = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "base" });
    defer freeResult(gpa, &first);
    try expectExit(first.term, 0);
    const older = try checkinHash(first.stdout);

    try writeFile(io, tmp.dir, "f.txt", "base\ntheirs\n");
    var second = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "second" });
    defer freeResult(gpa, &second);
    try expectExit(second.term, 0);
    const tip = try checkinHash(second.stdout);

    // Go back to the older check-in and start uncommitted work there — the
    // state an operator lands in when a shared branch moves under them.
    var back = try runZit(gpa, io, tmp.dir, &.{ "update", older });
    defer freeResult(gpa, &back);
    try expectExit(back.term, 0);
    try writeFile(io, tmp.dir, "f.txt", "mine\nbase\n");

    // `commit` still refuses, and still says to update. That is the guard doing
    // its job — the fork must stay deliberate.
    var blocked = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "blocked" });
    defer freeResult(gpa, &blocked);
    try expectExit(blocked.term, 1);
    try std.testing.expect(std.mem.indexOf(u8, blocked.stderr, "run 'zit update' to join it") != null);

    // Following that advice now works: the edits are merged onto the tip rather
    // than the update being refused. Disjoint regions merge without markers.
    var joined = try runZit(gpa, io, tmp.dir, &.{ "update", tip });
    defer freeResult(gpa, &joined);
    try expectExit(joined.term, 0);
    try expectCheckoutVersion(io, tmp.dir, tip);
    const merged = try readFile(gpa, io, tmp.dir, "f.txt");
    defer gpa.free(merged);
    try std.testing.expectEqualStrings("mine\nbase\ntheirs\n", merged);

    // And the commit that follows is an ordinary child of the tip: one leaf,
    // no `--allow-fork`, no repair check-in.
    var done = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "joined" });
    defer freeResult(gpa, &done);
    try expectExit(done.term, 0);
    const head = try checkinHash(done.stdout);

    var leaves = try runZit(gpa, io, tmp.dir, &.{"leaves"});
    defer freeResult(gpa, &leaves);
    try expectExit(leaves.term, 0);
    try std.testing.expect(std.mem.indexOf(u8, leaves.stdout, cli.shortHash(head)) != null);
    // Exactly one leaf line: a fork would show two.
    try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, leaves.stdout, "\n"));
}

test "cli update: a dirty checkout moves and three-way merges, marking conflicts" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "tracked.txt", "earlier\n");
    try addManaged(gpa, io, tmp.dir, &.{"tracked.txt"});

    var root_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "earlier" });
    defer freeResult(gpa, &root_commit);
    try expectExit(root_commit.term, 0);
    const root = try checkinHash(root_commit.stdout);

    try writeFile(io, tmp.dir, "tracked.txt", "committed later\n");
    var child_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "later" });
    defer freeResult(gpa, &child_commit);
    try expectExit(child_commit.term, 0);

    try writeFile(io, tmp.dir, "tracked.txt", "uncommitted change\n");

    // All three sides differ, so the merge cannot decide the file and writes an
    // envelope. That is a conflict (exit 1), NOT a refusal: this used to refuse
    // outright, which left an operator whose branch tip had moved under
    // uncommitted work with no way to join it at all.
    var update = try runZit(gpa, io, tmp.dir, &.{ "update", root });
    defer freeResult(gpa, &update);
    try expectExit(update.term, 1);
    try std.testing.expect(std.mem.indexOf(u8, update.stderr, "conflict in tracked.txt") != null);

    // The checkout MOVED — that is the whole point. A dirty tree is no longer a
    // reason to stay behind the tip.
    try expectCheckoutVersion(io, tmp.dir, root);
    try expectManaged(gpa, io, tmp.dir, &.{"tracked.txt"});

    // Both sides survive in the working file: the operator's uncommitted text
    // and the check-in being joined. Neither is silently discarded.
    const after_content = try readFile(gpa, io, tmp.dir, "tracked.txt");
    defer gpa.free(after_content);
    try std.testing.expect(std.mem.indexOf(u8, after_content, "uncommitted change") != null);
    try std.testing.expect(std.mem.indexOf(u8, after_content, "earlier") != null);
    try std.testing.expect(std.mem.indexOf(u8, after_content, "<<<<<<< current") != null);
}

test "cli update: a delta target materializes content inherited from its baseline" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "inherited.txt", "current content\n");
    try addManaged(gpa, io, tmp.dir, &.{"inherited.txt"});
    var current_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "current" });
    defer freeResult(gpa, &current_commit);
    try expectExit(current_commit.term, 0);

    const inherited = "inherited baseline content\n";
    const blob = try appendArtifact(gpa, io, tmp.dir, inherited);
    defer gpa.free(blob);
    const files = [_]artifact.FCard{.{
        .filename = "inherited.txt",
        .hash = blob,
        .perm = null,
        .old_name = null,
        .mode = .regular,
    }};
    const baseline = try appendDiffManifest(gpa, io, tmp.dir, "baseline", null, &files);
    defer gpa.free(baseline);
    const delta = try appendDiffManifest(gpa, io, tmp.dir, "delta", baseline, &.{});
    defer gpa.free(delta);

    var update = try runZit(gpa, io, tmp.dir, &.{ "update", delta });
    defer freeResult(gpa, &update);
    try expectExit(update.term, 0);
    try expectNoDiagnostic(update.stderr); // the receipt lives on stderr

    const materialized = try readFile(gpa, io, tmp.dir, "inherited.txt");
    defer gpa.free(materialized);
    try std.testing.expectEqualStrings(inherited, materialized);
    try expectCheckoutVersion(io, tmp.dir, delta);
    try expectManaged(gpa, io, tmp.dir, &.{"inherited.txt"});
}

test "cli update: non-ancestor control branch records set then cancel the target branch" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "tracked.txt", "content\n");
    try addManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
    var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "target" });
    defer freeResult(gpa, &commit);
    try expectExit(commit.term, 0);
    const target = try checkinHash(commit.stdout);

    try writeFile(io, tmp.dir, "tracked.txt", "child content\n");
    var child_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "child" });
    defer freeResult(gpa, &child_commit);
    try expectExit(child_commit.term, 0);
    const child = try checkinHash(child_commit.stdout);

    const set_control_id = try appendBranchControl(
        gpa,
        io,
        tmp.dir,
        "2020-01-01T00:00:00",
        .propagate,
        target,
        "feature",
    );
    defer gpa.free(set_control_id);

    var set_update = try runZit(gpa, io, tmp.dir, &.{ "update", target });
    defer freeResult(gpa, &set_update);
    try expectExit(set_update.term, 0);
    try expectNoDiagnostic(set_update.stderr); // the receipt lives on stderr
    {
        var checkout_buf: [checkout.max_ck_payload + 1]u8 = undefined;
        const current = (try checkout.read(io, tmp.dir, &checkout_buf)).?;
        try std.testing.expectEqualStrings(target, current.version);
        try std.testing.expectEqualStrings("feature", current.branch);
    }

    var reset = try runZit(gpa, io, tmp.dir, &.{ "update", child });
    defer freeResult(gpa, &reset);
    try expectExit(reset.term, 0);
    try expectNoDiagnostic(reset.stderr); // the receipt lives on stderr
    try expectCheckoutVersion(io, tmp.dir, child);

    const cancel_control_id = try appendBranchControl(
        gpa,
        io,
        tmp.dir,
        "2020-01-02T00:00:00",
        .cancel,
        target,
        null,
    );
    defer gpa.free(cancel_control_id);

    var cancel_update = try runZit(gpa, io, tmp.dir, &.{ "update", target });
    defer freeResult(gpa, &cancel_update);
    try expectExit(cancel_update.term, 0);
    try expectNoDiagnostic(cancel_update.stderr); // the receipt lives on stderr
    {
        var checkout_buf: [checkout.max_ck_payload + 1]u8 = undefined;
        const current = (try checkout.read(io, tmp.dir, &checkout_buf)).?;
        try std.testing.expectEqualStrings(target, current.version);
        try std.testing.expectEqualStrings("trunk", current.branch);
    }
}

test "cli update: unsafe and root-control target paths leave the checkout and outside sentinel unchanged" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;

    inline for (.{ ".zit", ".zit-checkout", ".zit-cache", "../outside/sentinel" }) |target_name| {
        var tmp = std.testing.tmpDir(.{});
        defer tmp.cleanup();
        try tmp.dir.createDir(io, "repo", .default_dir);
        try tmp.dir.createDir(io, "outside", .default_dir);
        var repo = try tmp.dir.openDir(io, "repo", .{});
        defer repo.close(io);
        var outside = try tmp.dir.openDir(io, "outside", .{});
        defer outside.close(io);

        try initRepo(gpa, io, repo);
        try writeFile(io, repo, "tracked.txt", "current\n");
        try addManaged(gpa, io, repo, &.{"tracked.txt"});
        var commit = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "current" });
        defer freeResult(gpa, &commit);
        try expectExit(commit.term, 0);
        const current = try checkinHash(commit.stdout);
        try writeFile(io, outside, "sentinel", "outside must survive\n");

        const payload = try appendArtifact(gpa, io, repo, "target content\n");
        defer gpa.free(payload);
        const files = [_]artifact.FCard{.{
            .filename = target_name,
            .hash = payload,
            .perm = null,
            .old_name = null,
            .mode = .regular,
        }};
        const target = try appendDiffManifest(gpa, io, repo, "unsafe target", null, &files);
        defer gpa.free(target);

        const before_log = try readFile(gpa, io, repo, ".zit");
        defer gpa.free(before_log);
        const before_checkout = try readFile(gpa, io, repo, ".zit-checkout");
        defer gpa.free(before_checkout);
        const before_managed = try readManagedImage(gpa, io, repo);
        defer gpa.free(before_managed);
        const before_tracked = try readFile(gpa, io, repo, "tracked.txt");
        defer gpa.free(before_tracked);
        const before_sentinel = try readFile(gpa, io, outside, "sentinel");
        defer gpa.free(before_sentinel);

        var update = try runZit(gpa, io, repo, &.{ "update", target });
        defer freeResult(gpa, &update);
        try expectExit(update.term, 1);
        try std.testing.expectEqualStrings("", update.stdout);

        const after_log = try readFile(gpa, io, repo, ".zit");
        defer gpa.free(after_log);
        const after_checkout = try readFile(gpa, io, repo, ".zit-checkout");
        defer gpa.free(after_checkout);
        const after_managed = try readManagedImage(gpa, io, repo);
        defer gpa.free(after_managed);
        const after_tracked = try readFile(gpa, io, repo, "tracked.txt");
        defer gpa.free(after_tracked);
        const after_sentinel = try readFile(gpa, io, outside, "sentinel");
        defer gpa.free(after_sentinel);
        try std.testing.expectEqualSlices(u8, before_log, after_log);
        try std.testing.expectEqualSlices(u8, before_checkout, after_checkout);
        try std.testing.expectEqualSlices(u8, before_managed, after_managed);
        try std.testing.expectEqualSlices(u8, before_tracked, after_tracked);
        try std.testing.expectEqualSlices(u8, before_sentinel, after_sentinel);
        try expectCheckoutVersion(io, repo, current);
        try expectManaged(gpa, io, repo, &.{"tracked.txt"});
    }
}

test "cli update: a target F-card cannot replace a symlink with an outside target" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try tmp.dir.createDir(io, "repo", .default_dir);
    try tmp.dir.createDir(io, "outside", .default_dir);
    var repo = try tmp.dir.openDir(io, "repo", .{});
    defer repo.close(io);
    var outside = try tmp.dir.openDir(io, "outside", .{});
    defer outside.close(io);

    try initRepo(gpa, io, repo);
    try writeFile(io, repo, "tracked.txt", "current\n");
    try addManaged(gpa, io, repo, &.{"tracked.txt"});
    var commit = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "current" });
    defer freeResult(gpa, &commit);
    try expectExit(commit.term, 0);
    const current = try checkinHash(commit.stdout);
    try writeFile(io, outside, "sentinel", "outside must survive\n");
    try repo.symLink(io, "../outside/sentinel", "link", .{});

    const payload = try appendArtifact(gpa, io, repo, "target content\n");
    defer gpa.free(payload);
    const files = [_]artifact.FCard{.{
        .filename = "link",
        .hash = payload,
        .perm = null,
        .old_name = null,
        .mode = .regular,
    }};
    const target = try appendDiffManifest(gpa, io, repo, "symlink target", null, &files);
    defer gpa.free(target);

    const before_checkout = try readFile(gpa, io, repo, ".zit-checkout");
    defer gpa.free(before_checkout);
    const before_managed = try readManagedImage(gpa, io, repo);
    defer gpa.free(before_managed);
    const before_tracked = try readFile(gpa, io, repo, "tracked.txt");
    defer gpa.free(before_tracked);
    const before_sentinel = try readFile(gpa, io, outside, "sentinel");
    defer gpa.free(before_sentinel);

    var update = try runZit(gpa, io, repo, &.{ "update", target });
    defer freeResult(gpa, &update);
    try expectExit(update.term, 1);
    try std.testing.expectEqualStrings("", update.stdout);

    const after_checkout = try readFile(gpa, io, repo, ".zit-checkout");
    defer gpa.free(after_checkout);
    const after_managed = try readManagedImage(gpa, io, repo);
    defer gpa.free(after_managed);
    const after_tracked = try readFile(gpa, io, repo, "tracked.txt");
    defer gpa.free(after_tracked);
    const after_link = try readFile(gpa, io, repo, "link");
    defer gpa.free(after_link);
    const after_sentinel = try readFile(gpa, io, outside, "sentinel");
    defer gpa.free(after_sentinel);
    try std.testing.expectEqualSlices(u8, before_checkout, after_checkout);
    try std.testing.expectEqualSlices(u8, before_managed, after_managed);
    try std.testing.expectEqualSlices(u8, before_tracked, after_tracked);
    try std.testing.expectEqualSlices(u8, before_sentinel, after_link);
    try std.testing.expectEqualSlices(u8, before_sentinel, after_sentinel);
    try expectCheckoutVersion(io, repo, current);
    try expectManaged(gpa, io, repo, &.{"tracked.txt"});
}

test "cli update: a symlink ancestor is rejected without following it outside the repository" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try tmp.dir.createDir(io, "repo", .default_dir);
    try tmp.dir.createDir(io, "outside", .default_dir);
    var repo = try tmp.dir.openDir(io, "repo", .{});
    defer repo.close(io);
    var outside = try tmp.dir.openDir(io, "outside", .{});
    defer outside.close(io);

    try initRepo(gpa, io, repo);
    try writeFile(io, repo, "tracked.txt", "current\n");
    try addManaged(gpa, io, repo, &.{"tracked.txt"});
    var commit = try runCommitEnv(gpa, io, repo, .{ .user = "u" }, &.{ "commit", "-m", "current" });
    defer freeResult(gpa, &commit);
    try expectExit(commit.term, 0);
    const current = try checkinHash(commit.stdout);
    try writeFile(io, outside, "sentinel", "outside must survive\n");
    try repo.symLink(io, "../outside", "link", .{});

    const payload = try appendArtifact(gpa, io, repo, "target content\n");
    defer gpa.free(payload);
    const files = [_]artifact.FCard{.{
        .filename = "link/sentinel",
        .hash = payload,
        .perm = null,
        .old_name = null,
        .mode = .regular,
    }};
    const target = try appendDiffManifest(gpa, io, repo, "symlink ancestor", null, &files);
    defer gpa.free(target);

    const before_checkout = try readFile(gpa, io, repo, ".zit-checkout");
    defer gpa.free(before_checkout);
    const before_managed = try readManagedImage(gpa, io, repo);
    defer gpa.free(before_managed);
    const before_tracked = try readFile(gpa, io, repo, "tracked.txt");
    defer gpa.free(before_tracked);
    const before_sentinel = try readFile(gpa, io, outside, "sentinel");
    defer gpa.free(before_sentinel);

    var update = try runZit(gpa, io, repo, &.{ "update", target });
    defer freeResult(gpa, &update);
    try expectExit(update.term, 1);
    try std.testing.expectEqualStrings("", update.stdout);

    const after_checkout = try readFile(gpa, io, repo, ".zit-checkout");
    defer gpa.free(after_checkout);
    const after_managed = try readManagedImage(gpa, io, repo);
    defer gpa.free(after_managed);
    const after_tracked = try readFile(gpa, io, repo, "tracked.txt");
    defer gpa.free(after_tracked);
    const after_sentinel = try readFile(gpa, io, outside, "sentinel");
    defer gpa.free(after_sentinel);
    try std.testing.expectEqualSlices(u8, before_checkout, after_checkout);
    try std.testing.expectEqualSlices(u8, before_managed, after_managed);
    try std.testing.expectEqualSlices(u8, before_tracked, after_tracked);
    try std.testing.expectEqualSlices(u8, before_sentinel, after_sentinel);
    try expectCheckoutVersion(io, repo, current);
    try expectManaged(gpa, io, repo, &.{"tracked.txt"});
}

test "cli update: file-to-directory transition round-trips through undo and redo" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "node", "old file\n");
    try addManaged(gpa, io, tmp.dir, &.{"node"});
    var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "file" });
    defer freeResult(gpa, &commit);
    try expectExit(commit.term, 0);
    const current = try checkinHash(commit.stdout);

    const child_content = "new child\n";
    const blob = try appendArtifact(gpa, io, tmp.dir, child_content);
    defer gpa.free(blob);
    const files = [_]artifact.FCard{.{
        .filename = "node/child.txt",
        .hash = blob,
        .perm = null,
        .old_name = null,
        .mode = .regular,
    }};
    const target = try appendDiffManifest(gpa, io, tmp.dir, "file to directory", null, &files);
    defer gpa.free(target);

    var update = try runZit(gpa, io, tmp.dir, &.{ "update", target });
    defer freeResult(gpa, &update);
    try expectExit(update.term, 0);
    try expectNoDiagnostic(update.stderr); // the receipt lives on stderr
    const child = try readFile(gpa, io, tmp.dir, "node/child.txt");
    defer gpa.free(child);
    try std.testing.expectEqualStrings(child_content, child);
    try expectCheckoutVersion(io, tmp.dir, target);
    try expectManaged(gpa, io, tmp.dir, &.{"node/child.txt"});

    var undo_res = try runZit(gpa, io, tmp.dir, &.{"undo"});
    defer freeResult(gpa, &undo_res);
    try expectExit(undo_res.term, 0);
    try expectNoDiagnostic(undo_res.stderr); // the receipt lives on stderr
    const restored = try readFile(gpa, io, tmp.dir, "node");
    defer gpa.free(restored);
    try std.testing.expectEqualStrings("old file\n", restored);
    try std.testing.expect(!fileExists(io, tmp.dir, "node/child.txt"));
    try expectCheckoutVersion(io, tmp.dir, current);
    try expectManaged(gpa, io, tmp.dir, &.{"node"});

    var redo_res = try runZit(gpa, io, tmp.dir, &.{"redo"});
    defer freeResult(gpa, &redo_res);
    try expectExit(redo_res.term, 0);
    try expectNoDiagnostic(redo_res.stderr); // the receipt lives on stderr
    const redone = try readFile(gpa, io, tmp.dir, "node/child.txt");
    defer gpa.free(redone);
    try std.testing.expectEqualStrings(child_content, redone);
    try expectCheckoutVersion(io, tmp.dir, target);
    try expectManaged(gpa, io, tmp.dir, &.{"node/child.txt"});
}

test "cli update: a clean managed directory can become a file" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try tmp.dir.createDir(io, "node", .default_dir);
    try writeFile(io, tmp.dir, "node/child.txt", "old child\n");
    try addManaged(gpa, io, tmp.dir, &.{"node/child.txt"});
    var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "directory" });
    defer freeResult(gpa, &commit);
    try expectExit(commit.term, 0);

    const file_content = "new file\n";
    const blob = try appendArtifact(gpa, io, tmp.dir, file_content);
    defer gpa.free(blob);
    const files = [_]artifact.FCard{.{
        .filename = "node",
        .hash = blob,
        .perm = null,
        .old_name = null,
        .mode = .regular,
    }};
    const target = try appendDiffManifest(gpa, io, tmp.dir, "directory to file", null, &files);
    defer gpa.free(target);

    var update = try runZit(gpa, io, tmp.dir, &.{ "update", target });
    defer freeResult(gpa, &update);
    try expectExit(update.term, 0);
    try expectNoDiagnostic(update.stderr); // the receipt lives on stderr
    const node = try readFile(gpa, io, tmp.dir, "node");
    defer gpa.free(node);
    try std.testing.expectEqualStrings(file_content, node);
    try std.testing.expect(!fileExists(io, tmp.dir, "node/child.txt"));
    try expectCheckoutVersion(io, tmp.dir, target);
    try expectManaged(gpa, io, tmp.dir, &.{"node"});
}

test "cli update: directory-to-file transition undo/redo treats descendants below restored file as absent" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try tmp.dir.createDir(io, "a", .default_dir);
    try writeFile(io, tmp.dir, "a/b", "old child\n");
    try addManaged(gpa, io, tmp.dir, &.{"a/b"});
    var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "directory" });
    defer freeResult(gpa, &commit);
    try expectExit(commit.term, 0);
    const current = try checkinHash(commit.stdout);

    const file_content = "new file\n";
    const blob = try appendArtifact(gpa, io, tmp.dir, file_content);
    defer gpa.free(blob);
    const files = [_]artifact.FCard{.{
        .filename = "a",
        .hash = blob,
        .perm = null,
        .old_name = null,
        .mode = .regular,
    }};
    const target = try appendDiffManifest(gpa, io, tmp.dir, "directory to file", null, &files);
    defer gpa.free(target);

    var update = try runZit(gpa, io, tmp.dir, &.{ "update", target });
    defer freeResult(gpa, &update);
    try expectExit(update.term, 0);
    try expectNoDiagnostic(update.stderr); // the receipt lives on stderr
    try std.testing.expect(sectionExists(gpa, io, tmp.dir, .undo));

    var undo_res = try runZit(gpa, io, tmp.dir, &.{"undo"});
    defer freeResult(gpa, &undo_res);
    try expectExit(undo_res.term, 0);
    try std.testing.expect(std.mem.endsWith(u8, undo_res.stdout, "undo: working tree restored\n"));
    try expectNoDiagnostic(undo_res.stderr); // the receipt lives on stderr
    const restored = try readFile(gpa, io, tmp.dir, "a/b");
    defer gpa.free(restored);
    try std.testing.expectEqualStrings("old child\n", restored);
    try expectCheckoutVersion(io, tmp.dir, current);
    try expectManaged(gpa, io, tmp.dir, &.{"a/b"});

    var redo_res = try runZit(gpa, io, tmp.dir, &.{"redo"});
    defer freeResult(gpa, &redo_res);
    try expectExit(redo_res.term, 0);
    try std.testing.expect(std.mem.endsWith(u8, redo_res.stdout, "redo: working tree restored\n"));
    try expectNoDiagnostic(redo_res.stderr); // the receipt lives on stderr
    const redone = try readFile(gpa, io, tmp.dir, "a");
    defer gpa.free(redone);
    try std.testing.expectEqualStrings(file_content, redone);
    try std.testing.expect(!fileExists(io, tmp.dir, "a/b"));
    try expectCheckoutVersion(io, tmp.dir, target);
    try expectManaged(gpa, io, tmp.dir, &.{"a"});
    try std.testing.expect(sectionExists(gpa, io, tmp.dir, .undo));

    var second_redo = try runZit(gpa, io, tmp.dir, &.{"redo"});
    defer freeResult(gpa, &second_redo);
    try expectExit(second_redo.term, 1);
    try std.testing.expectEqualStrings("", second_redo.stdout);
    try std.testing.expectEqualStrings("zit redo: nothing to redo\n", second_redo.stderr);
    const final_content = try readFile(gpa, io, tmp.dir, "a");
    defer gpa.free(final_content);
    try std.testing.expectEqualSlices(u8, redone, final_content);
}

test "cli update: an unmanaged descendant blocks a directory-to-file transition without mutation" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try tmp.dir.createDir(io, "node", .default_dir);
    try writeFile(io, tmp.dir, "node/tracked.txt", "managed child\n");
    try addManaged(gpa, io, tmp.dir, &.{"node/tracked.txt"});
    var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "directory" });
    defer freeResult(gpa, &commit);
    try expectExit(commit.term, 0);
    const current = try checkinHash(commit.stdout);
    try writeFile(io, tmp.dir, "node/unmanaged.txt", "must survive\n");

    const blob = try appendArtifact(gpa, io, tmp.dir, "would replace directory\n");
    defer gpa.free(blob);
    const files = [_]artifact.FCard{.{
        .filename = "node",
        .hash = blob,
        .perm = null,
        .old_name = null,
        .mode = .regular,
    }};
    const target = try appendDiffManifest(gpa, io, tmp.dir, "blocked directory to file", null, &files);
    defer gpa.free(target);

    const before_checkout = try readFile(gpa, io, tmp.dir, ".zit-checkout");
    defer gpa.free(before_checkout);
    const before_managed = try readManagedImage(gpa, io, tmp.dir);
    defer gpa.free(before_managed);
    const before_tracked = try readFile(gpa, io, tmp.dir, "node/tracked.txt");
    defer gpa.free(before_tracked);
    const before_unmanaged = try readFile(gpa, io, tmp.dir, "node/unmanaged.txt");
    defer gpa.free(before_unmanaged);

    var update = try runZit(gpa, io, tmp.dir, &.{ "update", target });
    defer freeResult(gpa, &update);
    try expectExit(update.term, 1);
    try std.testing.expectEqualStrings("", update.stdout);

    const after_checkout = try readFile(gpa, io, tmp.dir, ".zit-checkout");
    defer gpa.free(after_checkout);
    const after_managed = try readManagedImage(gpa, io, tmp.dir);
    defer gpa.free(after_managed);
    const after_tracked = try readFile(gpa, io, tmp.dir, "node/tracked.txt");
    defer gpa.free(after_tracked);
    const after_unmanaged = try readFile(gpa, io, tmp.dir, "node/unmanaged.txt");
    defer gpa.free(after_unmanaged);
    try std.testing.expectEqualSlices(u8, before_checkout, after_checkout);
    try std.testing.expectEqualSlices(u8, before_managed, after_managed);
    try std.testing.expectEqualSlices(u8, before_tracked, after_tracked);
    try std.testing.expectEqualSlices(u8, before_unmanaged, after_unmanaged);
    try expectCheckoutVersion(io, tmp.dir, current);
    try expectManaged(gpa, io, tmp.dir, &.{"node/tracked.txt"});
}

test "cli update: an executable F-card materializes an executable regular file" {
    if (comptime !File.Permissions.has_executable_bit) return error.SkipZigTest;

    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "script", "old\n");
    try addManaged(gpa, io, tmp.dir, &.{"script"});
    var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "regular" });
    defer freeResult(gpa, &commit);
    try expectExit(commit.term, 0);

    const script_content = "#!/bin/sh\necho updated\n";
    const blob = try appendArtifact(gpa, io, tmp.dir, script_content);
    defer gpa.free(blob);
    const files = [_]artifact.FCard{.{
        .filename = "script",
        .hash = blob,
        .perm = "x",
        .old_name = null,
        .mode = .executable,
    }};
    const target = try appendDiffManifest(gpa, io, tmp.dir, "executable target", null, &files);
    defer gpa.free(target);

    var update = try runZit(gpa, io, tmp.dir, &.{ "update", target });
    defer freeResult(gpa, &update);
    try expectExit(update.term, 0);
    try expectNoDiagnostic(update.stderr); // the receipt lives on stderr
    const script = try readFile(gpa, io, tmp.dir, "script");
    defer gpa.free(script);
    try std.testing.expectEqualStrings(script_content, script);
    var script_file = try tmp.dir.openFile(io, "script", .{ .mode = .read_only });
    defer script_file.close(io);
    try std.testing.expect((try script_file.stat(io)).permissions.toMode() & 0o111 != 0);
    try expectCheckoutVersion(io, tmp.dir, target);
    try expectManaged(gpa, io, tmp.dir, &.{"script"});
}

test "cli update: a locally added file rides across the move" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "tracked.txt", "earlier\n");
    try addManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
    var root_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "earlier" });
    defer freeResult(gpa, &root_commit);
    try expectExit(root_commit.term, 0);
    const root = try checkinHash(root_commit.stdout);
    try writeFile(io, tmp.dir, "tracked.txt", "later\n");
    var child_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "later" });
    defer freeResult(gpa, &child_commit);
    try expectExit(child_commit.term, 0);
    try writeFile(io, tmp.dir, "added.txt", "new membership\n");
    try addManaged(gpa, io, tmp.dir, &.{"added.txt"});

    // `added.txt` exists on neither check-in, so no side of the merge has an
    // opinion about it and it simply stays — staged, with its content intact.
    // Membership drift used to be a flat refusal.
    var update = try runZit(gpa, io, tmp.dir, &.{ "update", root });
    defer freeResult(gpa, &update);
    try expectExit(update.term, 0);
    try std.testing.expect(std.mem.indexOf(u8, update.stdout, "carried 1 local change") != null);

    try expectCheckoutVersion(io, tmp.dir, root);
    const after_added = try readFile(gpa, io, tmp.dir, "added.txt");
    defer gpa.free(after_added);
    try std.testing.expectEqualStrings("new membership\n", after_added);
    // The clean file took the target's content, exactly as a clean update.
    const after_tracked = try readFile(gpa, io, tmp.dir, "tracked.txt");
    defer gpa.free(after_tracked);
    try std.testing.expectEqualStrings("earlier\n", after_tracked);
    try expectManaged(gpa, io, tmp.dir, &.{ "added.txt", "tracked.txt" });
}

test "cli update: with no CHECKIN a bare update moves to the current branch's newest check-in, as Fossil's does" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "a", "one\n");
    try addManaged(gpa, io, tmp.dir, &.{"a"});
    var c1 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "c1" });
    defer freeResult(gpa, &c1);
    try expectExit(c1.term, 0);
    const c1_hash = try checkinHash(c1.stdout);
    try writeFile(io, tmp.dir, "a", "two\n");
    var c2 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "c2" });
    defer freeResult(gpa, &c2);
    try expectExit(c2.term, 0);
    const c2_hash = try checkinHash(c2.stdout);
    var back = try runZit(gpa, io, tmp.dir, &.{ "update", c1_hash });
    defer freeResult(gpa, &back);
    try expectExitDiag(back.term, 0, back);
    try expectFileContent(gpa, io, tmp.dir, "a", "one\n");
    var bare = try runZit(gpa, io, tmp.dir, &.{"update"});
    defer freeResult(gpa, &bare);
    try expectExitDiag(bare.term, 0, bare);
    try expectFileContent(gpa, io, tmp.dir, "a", "two\n");
    var st = try runZit(gpa, io, tmp.dir, &.{"status"});
    defer freeResult(gpa, &st);
    try std.testing.expect(std.mem.indexOf(u8, st.stdout, cli.shortHash(c2_hash)) != null);
}

test "cli update: a missing managed file preserves the current checkout" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "tracked.txt", "earlier\n");
    try addManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
    var root_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "earlier" });
    defer freeResult(gpa, &root_commit);
    try expectExit(root_commit.term, 0);
    const root = try checkinHash(root_commit.stdout);
    try writeFile(io, tmp.dir, "tracked.txt", "later\n");
    var child_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "later" });
    defer freeResult(gpa, &child_commit);
    try expectExit(child_commit.term, 0);
    const child = try checkinHash(child_commit.stdout);
    try tmp.dir.deleteFile(io, "tracked.txt");

    const before_checkout = try readFile(gpa, io, tmp.dir, ".zit-checkout");
    defer gpa.free(before_checkout);
    const before_managed = try readManagedImage(gpa, io, tmp.dir);
    defer gpa.free(before_managed);

    var update = try runZit(gpa, io, tmp.dir, &.{ "update", root });
    defer freeResult(gpa, &update);
    try expectExit(update.term, 1);
    try std.testing.expectEqualStrings("", update.stdout);

    const after_checkout = try readFile(gpa, io, tmp.dir, ".zit-checkout");
    defer gpa.free(after_checkout);
    const after_managed = try readManagedImage(gpa, io, tmp.dir);
    defer gpa.free(after_managed);
    try std.testing.expectEqualSlices(u8, before_checkout, after_checkout);
    try std.testing.expectEqualSlices(u8, before_managed, after_managed);
    try std.testing.expect(!fileExists(io, tmp.dir, "tracked.txt"));
    try expectCheckoutVersion(io, tmp.dir, child);
    try expectManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
}

test "cli update: executable-mode drift is carried onto the new content" {
    if (comptime !File.Permissions.has_executable_bit) return error.SkipZigTest;

    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "script", "earlier\n");
    try addManaged(gpa, io, tmp.dir, &.{"script"});
    var root_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "earlier" });
    defer freeResult(gpa, &root_commit);
    try expectExit(root_commit.term, 0);
    const root = try checkinHash(root_commit.stdout);
    try writeFile(io, tmp.dir, "script", "later\n");
    var child_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "later" });
    defer freeResult(gpa, &child_commit);
    try expectExit(child_commit.term, 0);
    {
        var script = try tmp.dir.openFile(io, "script", .{ .mode = .read_write });
        defer script.close(io);
        try script.setPermissions(io, File.Permissions.executable_file);
    }

    // The bytes are unchanged locally, so the target's content wins; the local
    // MODE is the local change, and B-merge-23 keeps the working file's side of
    // it. Mode drift used to refuse the update outright.
    var update = try runZit(gpa, io, tmp.dir, &.{ "update", root });
    defer freeResult(gpa, &update);
    try expectExit(update.term, 0);

    try expectCheckoutVersion(io, tmp.dir, root);
    const after_script = try readFile(gpa, io, tmp.dir, "script");
    defer gpa.free(after_script);
    try std.testing.expectEqualStrings("earlier\n", after_script);
    var script = try tmp.dir.openFile(io, "script", .{ .mode = .read_only });
    defer script.close(io);
    try std.testing.expect((try script.stat(io)).permissions.toMode() & 0o111 != 0);
    try expectManaged(gpa, io, tmp.dir, &.{"script"});
}

test "cli update: managed type drift preserves the current checkout" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "tracked", "earlier\n");
    try addManaged(gpa, io, tmp.dir, &.{"tracked"});
    var root_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "earlier" });
    defer freeResult(gpa, &root_commit);
    try expectExit(root_commit.term, 0);
    const root = try checkinHash(root_commit.stdout);
    try writeFile(io, tmp.dir, "tracked", "later\n");
    var child_commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "later" });
    defer freeResult(gpa, &child_commit);
    try expectExit(child_commit.term, 0);
    const child = try checkinHash(child_commit.stdout);
    try tmp.dir.deleteFile(io, "tracked");
    try tmp.dir.createDir(io, "tracked", .default_dir);
    try writeFile(io, tmp.dir, "tracked/nested.txt", "type drift\n");

    const before_checkout = try readFile(gpa, io, tmp.dir, ".zit-checkout");
    defer gpa.free(before_checkout);
    const before_managed = try readManagedImage(gpa, io, tmp.dir);
    defer gpa.free(before_managed);
    const before_nested = try readFile(gpa, io, tmp.dir, "tracked/nested.txt");
    defer gpa.free(before_nested);

    var update = try runZit(gpa, io, tmp.dir, &.{ "update", root });
    defer freeResult(gpa, &update);
    try expectExit(update.term, 1);
    try std.testing.expectEqualStrings("", update.stdout);

    const after_checkout = try readFile(gpa, io, tmp.dir, ".zit-checkout");
    defer gpa.free(after_checkout);
    const after_managed = try readManagedImage(gpa, io, tmp.dir);
    defer gpa.free(after_managed);
    const after_nested = try readFile(gpa, io, tmp.dir, "tracked/nested.txt");
    defer gpa.free(after_nested);
    try std.testing.expectEqualSlices(u8, before_checkout, after_checkout);
    try std.testing.expectEqualSlices(u8, before_managed, after_managed);
    try std.testing.expectEqualSlices(u8, before_nested, after_nested);
    try expectCheckoutVersion(io, tmp.dir, child);
    try expectManaged(gpa, io, tmp.dir, &.{"tracked"});
}

test "cli update: unresolvable check-in names do not mutate a repository" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    const Case = struct {
        id: []const u8,
        diagnostic: []const u8,
    };
    const cases = [_]Case{
        // CHANGED EXPECTATION (was "invalid check-in ID"): SF1 made `update`'s
        // argument a check-in NAME resolved through the shared §8.3 procedure,
        // so a non-hex string is no longer malformed by construction — it is a
        // symbolic name that resolves to nothing. The property this test exists
        // for is unchanged and still asserted below: exit 1, a `zit update: `
        // diagnostic, and a byte-identical repository.
        .{ .id = "not-an-id", .diagnostic = "not found" },
        .{
            .id = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
            .diagnostic = "not found",
        },
    };

    inline for (cases) |case| {
        var tmp = std.testing.tmpDir(.{});
        defer tmp.cleanup();
        try initRepo(gpa, io, tmp.dir);
        try writeFile(io, tmp.dir, "tracked.txt", "current\n");
        try addManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
        var commit = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "current" });
        defer freeResult(gpa, &commit);
        try expectExit(commit.term, 0);
        const current = try checkinHash(commit.stdout);

        const before_log = try readFile(gpa, io, tmp.dir, ".zit");
        defer gpa.free(before_log);
        const before_checkout = try readFile(gpa, io, tmp.dir, ".zit-checkout");
        defer gpa.free(before_checkout);
        const before_managed = try readManagedImage(gpa, io, tmp.dir);
        defer gpa.free(before_managed);
        const before_tracked = try readFile(gpa, io, tmp.dir, "tracked.txt");
        defer gpa.free(before_tracked);

        var update = try runZit(gpa, io, tmp.dir, &.{ "update", case.id });
        defer freeResult(gpa, &update);
        try expectExit(update.term, 1);
        try std.testing.expectEqualStrings("", update.stdout);
        try std.testing.expect(std.mem.startsWith(u8, update.stderr, "zit update: "));
        try std.testing.expect(std.mem.indexOf(u8, update.stderr, case.diagnostic) != null);
        try std.testing.expect(std.mem.endsWith(u8, update.stderr, "\n"));

        const after_log = try readFile(gpa, io, tmp.dir, ".zit");
        defer gpa.free(after_log);
        const after_checkout = try readFile(gpa, io, tmp.dir, ".zit-checkout");
        defer gpa.free(after_checkout);
        const after_managed = try readManagedImage(gpa, io, tmp.dir);
        defer gpa.free(after_managed);
        const after_tracked = try readFile(gpa, io, tmp.dir, "tracked.txt");
        defer gpa.free(after_tracked);
        try std.testing.expectEqualSlices(u8, before_log, after_log);
        try std.testing.expectEqualSlices(u8, before_checkout, after_checkout);
        try std.testing.expectEqualSlices(u8, before_managed, after_managed);
        try std.testing.expectEqualSlices(u8, before_tracked, after_tracked);
        try expectCheckoutVersion(io, tmp.dir, current);
        try expectManaged(gpa, io, tmp.dir, &.{"tracked.txt"});
    }
}

test "cli update: direct and routed help agree, and missing, extra, and invalid arguments are usage errors" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;

    {
        var tmp = std.testing.tmpDir(.{});
        defer tmp.cleanup();
        var direct = try runZit(gpa, io, tmp.dir, &.{ "update", "--help" });
        defer freeResult(gpa, &direct);
        try expectExit(direct.term, 0);
        try std.testing.expect(std.mem.startsWith(u8, direct.stdout, "usage: zit update "));
        try std.testing.expectEqualStrings("", direct.stderr);

        var routed = try runZit(gpa, io, tmp.dir, &.{ "help", "update" });
        defer freeResult(gpa, &routed);
        try expectExit(routed.term, 0);
        try std.testing.expectEqualSlices(u8, direct.stdout, routed.stdout);
        try std.testing.expectEqualStrings("", routed.stderr);
    }

    const Case = struct {
        argv: []const []const u8,
        stderr: []const u8,
    };
    const cases = [_]Case{
        .{
            .argv = &.{ "update", "a", "extra" },
            .stderr = "zit update: unexpected argument 'extra'\ntry 'zit update --help'\n",
        },
        .{
            .argv = &.{ "update", "-x" },
            .stderr = "zit update: unknown option '-x'\ntry 'zit update --help'\n",
        },
    };
    inline for (cases) |case| {
        var tmp = std.testing.tmpDir(.{});
        defer tmp.cleanup();
        var res = try runZit(gpa, io, tmp.dir, case.argv);
        defer freeResult(gpa, &res);
        try expectExit(res.term, 2);
        try std.testing.expectEqualStrings("", res.stdout);
        try std.testing.expectEqualStrings(case.stderr, res.stderr);
    }
}

test "cli update --cone widens a sparse store through the saved remote" {
    // Sparse-cone RFC section 6.4, update's half: widening the cone past the
    // store's holdings rewrites store policy and pulls the newly covered
    // content; --dense densifies the same way. The narrow request needs no
    // fetch at all.
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    try initRepo(gpa, io, tmp_a.dir);
    try tmp_a.dir.createDir(io, "src", .default_dir);
    try tmp_a.dir.createDir(io, "tools", .default_dir);
    try tmp_a.dir.createDir(io, "docs", .default_dir);
    try writeFile(io, tmp_a.dir, "src/a.zig", "src\n");
    try writeFile(io, tmp_a.dir, "tools/t.bin", "tools\n");
    try writeFile(io, tmp_a.dir, "docs/d.md", "docs\n");
    try addManaged(gpa, io, tmp_a.dir, &.{ "src/a.zig", "tools/t.bin", "docs/d.md" });
    const head = try commitHashDup(gpa, io, tmp_a.dir, "seed");
    defer gpa.free(head);

    const port = try freshLoopbackPort(io);
    var server = try spawnServe(gpa, io, tmp_a.dir, port);
    defer server.kill(io);
    try waitForListen(io, port);
    const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
    defer gpa.free(url);

    var tmp_b = std.testing.tmpDir(.{});
    defer tmp_b.cleanup();
    var clone = try runZit(gpa, io, tmp_b.dir, &.{ "clone", "--no-open", "--cone=src", url, "repo" });
    defer freeResult(gpa, &clone);
    try expectExitDiag(clone.term, 0, clone);
    var b_dir = try tmp_b.dir.openDir(io, "repo", .{});
    defer b_dir.close(io);
    var op = try runZit(gpa, io, b_dir, &.{ "open", "--cone=src" });
    defer freeResult(gpa, &op);
    try expectExitDiag(op.term, 0, op);
    try std.testing.expect(!fileExists(io, b_dir, "tools/t.bin"));

    // Widen: src -> src+tools. The store lacks tools' blob; the fetch fires.
    var widen = try runZit(gpa, io, b_dir, &.{ "update", "--cone=src", "--cone=tools", head });
    defer freeResult(gpa, &widen);
    try expectExitDiag(widen.term, 0, widen);
    try std.testing.expect(std.mem.indexOf(u8, widen.stderr, "fetching from the saved remote") != null);
    const tools_content = try readFile(gpa, io, b_dir, "tools/t.bin");
    defer gpa.free(tools_content);
    try std.testing.expectEqualStrings("tools\n", tools_content);
    try std.testing.expect(!fileExists(io, b_dir, "docs/d.md")); // still outside the cone

    // Densify: --dense fetches the remainder.
    var dense = try runZit(gpa, io, b_dir, &.{ "update", "--dense", head });
    defer freeResult(gpa, &dense);
    try expectExitDiag(dense.term, 0, dense);
    const docs_content = try readFile(gpa, io, b_dir, "docs/d.md");
    defer gpa.free(docs_content);
    try std.testing.expectEqualStrings("docs\n", docs_content);
}

test "cli update: the receipt names every moved file and the check-ins, -n changes nothing, --latest names the branch tip" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "a.txt", "one\n");
    try writeFile(io, tmp.dir, "gone.txt", "x\n");
    try addManaged(gpa, io, tmp.dir, &.{ "a.txt", "gone.txt" });
    var c1 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "base" });
    defer freeResult(gpa, &c1);
    try expectExitDiag(c1.term, 0, c1);
    const base = try checkinHash(c1.stdout);
    try writeFile(io, tmp.dir, "a.txt", "two\n");
    try writeFile(io, tmp.dir, "new.txt", "n\n");
    var rm = try runZit(gpa, io, tmp.dir, &.{ "rm", "--hard", "gone.txt" });
    defer freeResult(gpa, &rm);
    try expectExitDiag(rm.term, 0, rm);
    try addManaged(gpa, io, tmp.dir, &.{"new.txt"});
    var c2 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "second" });
    defer freeResult(gpa, &c2);
    try expectExitDiag(c2.term, 0, c2);
    const second = try checkinHash(c2.stdout);

    // Dry run: the same receipt, nothing written.
    var dry = try runZit(gpa, io, tmp.dir, &.{ "update", "-n", base });
    defer freeResult(gpa, &dry);
    try expectExitDiag(dry.term, 0, dry);
    try std.testing.expectEqualStrings("", dry.stdout);
    try std.testing.expect(std.mem.indexOf(u8, dry.stderr, "UPDATE a.txt\nADD gone.txt\nREMOVE new.txt\n") != null);
    try std.testing.expect(std.mem.indexOf(u8, dry.stderr, "(dry run: nothing was changed)") != null);
    const nt = try readFile(gpa, io, tmp.dir, "new.txt"); // still there, untouched
    defer gpa.free(nt);
    try std.testing.expectEqualStrings("n\n", nt);
    var still = try runZit(gpa, io, tmp.dir, &.{"status"});
    defer freeResult(gpa, &still);
    try std.testing.expect(std.mem.indexOf(u8, still.stdout, cli.shortHash(second)) != null);

    // The real move: per-file lines, the from/to block, the undo hint — all on stderr.
    var up = try runZit(gpa, io, tmp.dir, &.{ "update", base });
    defer freeResult(gpa, &up);
    try expectExitDiag(up.term, 0, up);
    try std.testing.expectEqualStrings("", up.stdout);
    try std.testing.expect(std.mem.indexOf(u8, up.stderr, "UPDATE a.txt\nADD gone.txt\nREMOVE new.txt\n") != null);
    try std.testing.expect(std.mem.indexOf(u8, up.stderr, "updated-from: " ++ "") != null);
    try std.testing.expect(std.mem.indexOf(u8, up.stderr, second[0..12]) != null);
    try std.testing.expect(std.mem.indexOf(u8, up.stderr, "updated-to:   ") != null);
    try std.testing.expect(std.mem.indexOf(u8, up.stderr, base[0..12]) != null);
    try std.testing.expect(std.mem.indexOf(u8, up.stderr, "tags:         trunk") != null);
    try std.testing.expect(std.mem.indexOf(u8, up.stderr, "comment:      base (user: u)") != null);
    try std.testing.expect(std.mem.indexOf(u8, up.stderr, "changes:      1 file modified, 1 added, 1 removed.") != null);
    try std.testing.expect(std.mem.indexOf(u8, up.stderr, "\"zit undo\" is available") != null);

    // Already there: the block says so, no per-file lines, no undo hint.
    var noop = try runZit(gpa, io, tmp.dir, &.{ "update", base });
    defer freeResult(gpa, &noop);
    try expectExitDiag(noop.term, 0, noop);
    try std.testing.expect(std.mem.indexOf(u8, noop.stderr, "changes:      none. Already up-to-date.") != null);
    try std.testing.expect(std.mem.indexOf(u8, noop.stderr, "UPDATE") == null);
    try std.testing.expect(std.mem.indexOf(u8, noop.stderr, "zit undo") == null);

    // --latest: the branch tip, by name, in place of CHECKIN; -v lists the unchanged.
    var latest = try runZit(gpa, io, tmp.dir, &.{ "update", "--latest", "-v" });
    defer freeResult(gpa, &latest);
    try expectExitDiag(latest.term, 0, latest);
    try std.testing.expect(std.mem.indexOf(u8, latest.stderr, "updated-to:   " ++ "") != null);
    try std.testing.expect(std.mem.indexOf(u8, latest.stderr, second[0..12]) != null);
    try std.testing.expect(std.mem.indexOf(u8, latest.stderr, "UPDATE a.txt") != null);
    var both = try runZit(gpa, io, tmp.dir, &.{ "update", "--latest", base });
    defer freeResult(gpa, &both);
    try expectExit(both.term, 2);

    // A carried local edit is reported as MERGE (or CONFLICT when the
    // three-way merge cannot decide); either way the receipt names it.
    try writeFile(io, tmp.dir, "a.txt", "two\nlocal\n");
    var carried = try runZit(gpa, io, tmp.dir, &.{ "update", base });
    defer freeResult(gpa, &carried);
    switch (carried.term) {
        .exited => |c| try std.testing.expect(c == 0 or c == 1),
        else => return error.TestUnexpectedExitCode,
    }
    try std.testing.expect(std.mem.indexOf(u8, carried.stderr, "MERGE a.txt") != null or std.mem.indexOf(u8, carried.stderr, "CONFLICT a.txt") != null);
    try std.testing.expect(std.mem.indexOf(u8, carried.stderr, "\"zit undo\" is available") != null);
}