Skip to content
zit Artifact [304e9f3661]
Login

Artifact [304e9f3661]

Artifact 304e9f36617ff092c7ad800944578a10b530f319f7188c83dc05126d3fbd9b42:


const std = @import("std");
const checkout = @import("zit").checkout;
const zit = @import("zit");
const support = @import("support.zig");
const addManaged = support.addManaged;
const adoptStore = support.adoptStore;
const appendArtifact = support.appendArtifact;
const checkinHash = support.checkinHash;
const checkoutVersionAlloc = support.checkoutVersionAlloc;
const commitHashDup = support.commitHashDup;
const expectCheckout = support.expectCheckout;
const expectCheckoutVersion = support.expectCheckoutVersion;
const expectExit = support.expectExit;
const expectExitDiag = support.expectExitDiag;
const expectFileContent = support.expectFileContent;
const fileExists = support.fileExists;
const freeResult = support.freeResult;
const freshLoopbackPort = support.freshLoopbackPort;
const initRepo = support.initRepo;
const leafSubManifest = support.leafSubManifest;
const parseCheckin = support.parseCheckin;
const readFile = support.readFile;
const runCommitEnv = support.runCommitEnv;
const runZit = support.runZit;
const seedCheckout = support.seedCheckout;
const sha3HexAlloc = support.sha3HexAlloc;
const shunDigestInRepo = support.shunDigestInRepo;
const spawnServe = support.spawnServe;
const waitForListen = support.waitForListen;
const withZCard = support.withZCard;
const writeFile = support.writeFile;

test "cli sparse cone P4: open --cone scopes materialization, tracking, extras, and add refusal" {
    // Goal: one sparse checkout exercises the section 4.1 surface end to end:
    // only the cone materializes; the managed set is in-cone; an uncovered
    // on-disk file is invisible to extras; an explicit add outside the cone
    // refuses naming the mechanism (never "no such file"/"corrupt"); status
    // stays clean. Method: build a two-directory repo, adopt its store into a
    // fresh dir, open --cone=src, then probe each verb.
    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 writeFile(io, tmp_a.dir, "rootfile.txt", "root\n");
    try tmp_a.dir.createDir(io, "src", .default_dir);
    try tmp_a.dir.createDir(io, "tools", .default_dir);
    try writeFile(io, tmp_a.dir, "src/a.zig", "a\n");
    try writeFile(io, tmp_a.dir, "src/b.zig", "b\n");
    try writeFile(io, tmp_a.dir, "tools/t.sh", "t\n");
    try addManaged(gpa, io, tmp_a.dir, &.{ "rootfile.txt", "src/a.zig", "src/b.zig", "tools/t.sh" });
    const head = try commitHashDup(gpa, io, tmp_a.dir, "base");
    defer gpa.free(head);

    var tmp_b = std.testing.tmpDir(.{});
    defer tmp_b.cleanup();
    try initRepo(gpa, io, tmp_b.dir);
    try adoptStore(gpa, io, tmp_a.dir, tmp_b.dir);

    var opened = try runZit(gpa, io, tmp_b.dir, &.{ "open", "--cone=src" });
    defer freeResult(gpa, &opened);
    try expectExitDiag(opened.term, 0, opened);
    try expectCheckoutVersion(io, tmp_b.dir, head);

    // Positive space: the cone materialized. Negative space: nothing else did.
    try std.testing.expect(fileExists(io, tmp_b.dir, "src/a.zig"));
    try std.testing.expect(fileExists(io, tmp_b.dir, "src/b.zig"));
    try std.testing.expect(!fileExists(io, tmp_b.dir, "rootfile.txt"));
    try std.testing.expect(!fileExists(io, tmp_b.dir, "tools/t.sh"));

    // A sparse checkout is CLEAN: the out-of-cone entries live in the record,
    // not the managed set, and status compares cone against cone.
    var st = try runZit(gpa, io, tmp_b.dir, &.{"status"});
    defer freeResult(gpa, &st);
    try expectExitDiag(st.term, 0, st);
    try std.testing.expect(std.mem.indexOf(u8, st.stdout, "removed") == null);
    try std.testing.expect(std.mem.indexOf(u8, st.stdout, "missing") == null);

    // An uncovered on-disk file is NOT an extra (section 4.1).
    try writeFile(io, tmp_b.dir, "stray.txt", "outside\n");
    try writeFile(io, tmp_b.dir, "src/new.zig", "inside\n");
    var ex = try runZit(gpa, io, tmp_b.dir, &.{"extras"});
    defer freeResult(gpa, &ex);
    try expectExitDiag(ex.term, 0, ex);
    try std.testing.expectEqualStrings("src/new.zig\n", ex.stdout);

    // Explicit add outside the cone: exit 1, names the mechanism and both
    // remedies, whole-stderr asserted so wording changes come through here.
    var ad = try runZit(gpa, io, tmp_b.dir, &.{ "add", "stray.txt" });
    defer freeResult(gpa, &ad);
    try expectExit(ad.term, 1);
    try std.testing.expectEqualStrings(
        "zit add: 'stray.txt' is outside this checkout's sparse cone\n" ++
            "widen it with 'zit update --cone=stray.txt' or return to dense with 'zit update --dense'\n",
        ad.stderr,
    );
    try std.testing.expect(std.mem.indexOf(u8, ad.stderr, "no such file") == null);
    try std.testing.expect(std.mem.indexOf(u8, ad.stderr, "corrupt") == null);

    // In-cone add works; `add .` expands to the cone only.
    var ad2 = try runZit(gpa, io, tmp_b.dir, &.{ "add", "." });
    defer freeResult(gpa, &ad2);
    try expectExitDiag(ad2.term, 0, ad2);
    try std.testing.expect(std.mem.indexOf(u8, ad2.stdout, "src/new.zig") != null);
    try std.testing.expect(std.mem.indexOf(u8, ad2.stdout, "stray.txt") == null);
}

test "cli sparse cone P4: update --dense rematerializes the full tree and re-scopes extras" {
    // Goal: section 5.4's ultimate widening -- dropping the cone -- restores
    // every out-of-cone file and returns the verbs to dense behavior. Method:
    // sparse open as above, then `update --dense` at the same check-in.
    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 writeFile(io, tmp_a.dir, "src/a.zig", "a\n");
    try writeFile(io, tmp_a.dir, "tools/t.sh", "t\n");
    try addManaged(gpa, io, tmp_a.dir, &.{ "src/a.zig", "tools/t.sh" });
    const head = try commitHashDup(gpa, io, tmp_a.dir, "base");
    defer gpa.free(head);

    var tmp_b = std.testing.tmpDir(.{});
    defer tmp_b.cleanup();
    try initRepo(gpa, io, tmp_b.dir);
    try adoptStore(gpa, io, tmp_a.dir, tmp_b.dir);
    var opened = try runZit(gpa, io, tmp_b.dir, &.{ "open", "--cone=src" });
    defer freeResult(gpa, &opened);
    try expectExitDiag(opened.term, 0, opened);
    try std.testing.expect(!fileExists(io, tmp_b.dir, "tools/t.sh"));

    var up = try runZit(gpa, io, tmp_b.dir, &.{ "update", "--dense", head });
    defer freeResult(gpa, &up);
    try expectExitDiag(up.term, 0, up);
    try std.testing.expect(fileExists(io, tmp_b.dir, "tools/t.sh"));
    try std.testing.expect(fileExists(io, tmp_b.dir, "src/a.zig"));

    // Dense again: a stray file is an extra once more.
    try writeFile(io, tmp_b.dir, "stray.txt", "outside\n");
    var ex = try runZit(gpa, io, tmp_b.dir, &.{"extras"});
    defer freeResult(gpa, &ex);
    try expectExitDiag(ex.term, 0, ex);
    try std.testing.expectEqualStrings("stray.txt\n", ex.stdout);
}

test "cli sparse cone P5 keystone: a sparse commit is indistinguishable from the dense commit of the same change" {
    // Goal: RFC section 4.2's central claim. Two clones of one repo make the
    // SAME logical change -- edit src/a.zig, add src/new.zig -- one densely,
    // one through a src-only cone. The minted check-ins must agree on their
    // complete file sets (out-of-cone entries carried verbatim, R card and
    // all), the sparse one must reopen densely elsewhere with every file
    // intact, and verify must be clean. Method: byte-compare `zit ls` output
    // and per-file `zit cat` across the two results.
    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 writeFile(io, tmp_a.dir, "src/a.zig", "a v1\n");
    try writeFile(io, tmp_a.dir, "tools/t.sh", "tool\n");
    try writeFile(io, tmp_a.dir, "README", "readme\n");
    try addManaged(gpa, io, tmp_a.dir, &.{ "src/a.zig", "tools/t.sh", "README" });
    const base = try commitHashDup(gpa, io, tmp_a.dir, "base");
    defer gpa.free(base);

    // Dense arm: ordinary checkout, make the change, commit.
    var dense = std.testing.tmpDir(.{});
    defer dense.cleanup();
    try initRepo(gpa, io, dense.dir);
    try adoptStore(gpa, io, tmp_a.dir, dense.dir);
    var od = try runZit(gpa, io, dense.dir, &.{"open"});
    defer freeResult(gpa, &od);
    try expectExitDiag(od.term, 0, od);
    try writeFile(io, dense.dir, "src/a.zig", "a v2\n");
    try writeFile(io, dense.dir, "src/new.zig", "new\n");
    var ad = try runZit(gpa, io, dense.dir, &.{ "add", "src/new.zig" });
    defer freeResult(gpa, &ad);
    try expectExitDiag(ad.term, 0, ad);
    var cd = try runZit(gpa, io, dense.dir, &.{ "commit", "-m", "same change", "--user", "e2e" });
    defer freeResult(gpa, &cd);
    try expectExitDiag(cd.term, 0, cd);

    // Sparse arm: src-only cone, the same change, commit.
    var sparse = std.testing.tmpDir(.{});
    defer sparse.cleanup();
    try initRepo(gpa, io, sparse.dir);
    try adoptStore(gpa, io, tmp_a.dir, sparse.dir);
    var os_ = try runZit(gpa, io, sparse.dir, &.{ "open", "--cone=src" });
    defer freeResult(gpa, &os_);
    try expectExitDiag(os_.term, 0, os_);
    try std.testing.expect(!fileExists(io, sparse.dir, "tools/t.sh"));
    try writeFile(io, sparse.dir, "src/a.zig", "a v2\n");
    try writeFile(io, sparse.dir, "src/new.zig", "new\n");
    var as_ = try runZit(gpa, io, sparse.dir, &.{ "add", "src/new.zig" });
    defer freeResult(gpa, &as_);
    try expectExitDiag(as_.term, 0, as_);
    var cs = try runZit(gpa, io, sparse.dir, &.{ "commit", "-m", "same change", "--user", "e2e" });
    defer freeResult(gpa, &cs);
    try expectExitDiag(cs.term, 0, cs);

    // The two tips enumerate identical COMPLETE file sets: `ls` output must
    // be byte-equal, and it must still contain the out-of-cone files.
    var ls_dense = try runZit(gpa, io, dense.dir, &.{"ls"});
    defer freeResult(gpa, &ls_dense);
    try expectExitDiag(ls_dense.term, 0, ls_dense);
    var ls_sparse = try runZit(gpa, io, sparse.dir, &.{"ls"});
    defer freeResult(gpa, &ls_sparse);
    try expectExitDiag(ls_sparse.term, 0, ls_sparse);
    try std.testing.expectEqualStrings(ls_dense.stdout, ls_sparse.stdout);
    try std.testing.expect(std.mem.indexOf(u8, ls_sparse.stdout, "tools/t.sh") != null);
    try std.testing.expect(std.mem.indexOf(u8, ls_sparse.stdout, "README") != null);

    // Out-of-cone content carried verbatim: cat from the sparse store.
    var cat_tool = try runZit(gpa, io, sparse.dir, &.{ "cat", "tools/t.sh" });
    defer freeResult(gpa, &cat_tool);
    try expectExitDiag(cat_tool.term, 0, cat_tool);
    try std.testing.expectEqualStrings("tool\n", cat_tool.stdout);

    // The sparse store verifies clean, and a fresh DENSE open of it
    // materializes the full tree including the sparse-committed change.
    var ver = try runZit(gpa, io, sparse.dir, &.{"verify"});
    defer freeResult(gpa, &ver);
    try expectExitDiag(ver.term, 0, ver);

    var reader = std.testing.tmpDir(.{});
    defer reader.cleanup();
    try initRepo(gpa, io, reader.dir);
    try adoptStore(gpa, io, sparse.dir, reader.dir);
    var or_ = try runZit(gpa, io, reader.dir, &.{"open"});
    defer freeResult(gpa, &or_);
    try expectExitDiag(or_.term, 0, or_);
    const a2 = try readFile(gpa, io, reader.dir, "src/a.zig");
    defer gpa.free(a2);
    try std.testing.expectEqualStrings("a v2\n", a2);
    const t2 = try readFile(gpa, io, reader.dir, "tools/t.sh");
    defer gpa.free(t2);
    try std.testing.expectEqualStrings("tool\n", t2);
}

test "cli sparse cone P5: in-cone deletion commits as a deletion; out-of-cone files never deleted by absence" {
    // Goal: the sparse snapshot's negative space -- rm of an in-cone file is
    // a real deletion, while every out-of-cone file (absent from the sparse
    // worktree by definition) survives the commit untouched. This is the
    // data-loss trap the compose carry exists to prevent.
    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 writeFile(io, tmp_a.dir, "src/a.zig", "a\n");
    try writeFile(io, tmp_a.dir, "src/b.zig", "b\n");
    try writeFile(io, tmp_a.dir, "tools/t.sh", "tool\n");
    try addManaged(gpa, io, tmp_a.dir, &.{ "src/a.zig", "src/b.zig", "tools/t.sh" });
    const base = try commitHashDup(gpa, io, tmp_a.dir, "base");
    defer gpa.free(base);

    var sp = std.testing.tmpDir(.{});
    defer sp.cleanup();
    try initRepo(gpa, io, sp.dir);
    try adoptStore(gpa, io, tmp_a.dir, sp.dir);
    var op = try runZit(gpa, io, sp.dir, &.{ "open", "--cone=src" });
    defer freeResult(gpa, &op);
    try expectExitDiag(op.term, 0, op);

    var rm = try runZit(gpa, io, sp.dir, &.{ "rm", "src/b.zig" });
    defer freeResult(gpa, &rm);
    try expectExitDiag(rm.term, 0, rm);
    sp.dir.deleteFile(io, "src/b.zig") catch {};
    var cm = try runZit(gpa, io, sp.dir, &.{ "commit", "-m", "drop b", "--user", "e2e" });
    defer freeResult(gpa, &cm);
    try expectExitDiag(cm.term, 0, cm);

    var ls = try runZit(gpa, io, sp.dir, &.{"ls"});
    defer freeResult(gpa, &ls);
    try expectExitDiag(ls.term, 0, ls);
    try std.testing.expect(std.mem.indexOf(u8, ls.stdout, "src/b.zig") == null); // deleted
    try std.testing.expect(std.mem.indexOf(u8, ls.stdout, "src/a.zig") != null); // kept
    try std.testing.expect(std.mem.indexOf(u8, ls.stdout, "tools/t.sh") != null); // CARRIED
}

test "cli sparse cone P6: narrowing dematerializes; status and vstat stay correct, never wrong" {
    // Goal: RFC section 3.1 mutability + the cache-key audit (PLAN Task 6) --
    // a cone change on an existing checkout costs a flatten, never a wrong
    // answer. Narrowing from dense removes out-of-cone files from the tree
    // (the record keeps them); status is clean before and after; widening
    // back restores them.
    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 writeFile(io, tmp_a.dir, "src/a.zig", "a\n");
    try writeFile(io, tmp_a.dir, "tools/t.sh", "tool\n");
    try addManaged(gpa, io, tmp_a.dir, &.{ "src/a.zig", "tools/t.sh" });
    const head = try commitHashDup(gpa, io, tmp_a.dir, "base");
    defer gpa.free(head);

    var wt = std.testing.tmpDir(.{});
    defer wt.cleanup();
    try initRepo(gpa, io, wt.dir);
    try adoptStore(gpa, io, tmp_a.dir, wt.dir);
    var op = try runZit(gpa, io, wt.dir, &.{"open"});
    defer freeResult(gpa, &op);
    try expectExitDiag(op.term, 0, op);
    try std.testing.expect(fileExists(io, wt.dir, "tools/t.sh"));

    // Narrow: dense -> src cone at the same check-in.
    var nr = try runZit(gpa, io, wt.dir, &.{ "update", "--cone=src", head });
    defer freeResult(gpa, &nr);
    try expectExitDiag(nr.term, 0, nr);
    try std.testing.expect(!fileExists(io, wt.dir, "tools/t.sh")); // dematerialized
    try std.testing.expect(fileExists(io, wt.dir, "src/a.zig"));

    var st = try runZit(gpa, io, wt.dir, &.{"status"});
    defer freeResult(gpa, &st);
    try expectExitDiag(st.term, 0, st);
    try std.testing.expect(std.mem.indexOf(u8, st.stdout, "removed") == null);
    try std.testing.expect(std.mem.indexOf(u8, st.stdout, "missing") == null);

    // Widen back to dense: everything returns, still clean.
    var wd = try runZit(gpa, io, wt.dir, &.{ "update", "--dense", head });
    defer freeResult(gpa, &wd);
    try expectExitDiag(wd.term, 0, wd);
    try std.testing.expect(fileExists(io, wt.dir, "tools/t.sh"));
    var st2 = try runZit(gpa, io, wt.dir, &.{"status"});
    defer freeResult(gpa, &st2);
    try expectExitDiag(st2.term, 0, st2);
    try std.testing.expect(std.mem.indexOf(u8, st2.stdout, "removed") == null);
}

test "cli sparse commit reconstructs missing structural siblings or refuses without publishing" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    const Case = enum { no_remote, complete_peer, incomplete_peer, corrupt_sibling, shunned_sibling, delta_peer };
    for (std.meta.tags(Case)) |case| {
        const complete_peer = case == .complete_peer or case == .delta_peer;
        var source = std.testing.tmpDir(.{});
        defer source.cleanup();
        try initRepo(gpa, io, source.dir);
        var enabled = try runZit(gpa, io, source.dir, &.{ "submanifest", "enable", "--k", "1" });
        defer freeResult(gpa, &enabled);
        try expectExitDiag(enabled.term, 0, enabled);
        const src_leaf = try leafSubManifest(gpa, &.{"src/a"});
        defer gpa.free(src_leaf);
        const tools_leaf = if (case == .corrupt_sibling)
            try gpa.dupe(u8, "malformed sibling\n")
        else
            try leafSubManifest(gpa, &.{"tools/b"});
        defer gpa.free(tools_leaf);
        const src_hash = try appendArtifact(gpa, io, source.dir, src_leaf);
        defer gpa.free(src_hash);
        const tools_hash = try sha3HexAlloc(gpa, tools_leaf);
        defer gpa.free(tools_hash);
        const src_blob = try appendArtifact(gpa, io, source.dir, "src/a");
        defer gpa.free(src_blob);
        const body = try std.fmt.allocPrint(gpa, "C base\nD 2026-10-20T12:00:00.000\nS src/a {s}\nS tools/b {s}\nT *branch * trunk\nT *sym-trunk *\nU e2e\n", .{ src_hash, tools_hash });
        defer gpa.free(body);
        const tree = try withZCard(gpa, body);
        defer gpa.free(tree);
        const tree_base = try appendArtifact(gpa, io, source.dir, tree);
        defer gpa.free(tree_base);
        const base = if (case == .delta_peer) blk: {
            const delta_body = try std.fmt.allocPrint(gpa, "B {s}\nC delta-parent\nD 2026-10-20T12:00:01.000\nP {s}\nU e2e\n", .{ tree_base, tree_base });
            defer gpa.free(delta_body);
            const delta_bytes = try withZCard(gpa, delta_body);
            defer gpa.free(delta_bytes);
            break :blk try appendArtifact(gpa, io, source.dir, delta_bytes);
        } else try gpa.dupe(u8, tree_base);
        defer gpa.free(base);

        var sparse = std.testing.tmpDir(.{});
        defer sparse.cleanup();
        try initRepo(gpa, io, sparse.dir);
        try adoptStore(gpa, io, source.dir, sparse.dir);
        // Model an already-materialized sparse checkout after its opaque
        // sibling payload was elided; opening a new checkout needs the tree.
        try sparse.dir.createDir(io, "src", .default_dir);
        try writeFile(io, sparse.dir, "src/a", "src/a");
        try addManaged(gpa, io, sparse.dir, &.{"src/a"});
        try seedCheckout(io, sparse.dir, base, "trunk");
        var store_cone = try zit.cone.Cone.init(gpa, &.{"src"}, &.{});
        defer store_cone.deinit(gpa);
        const cone_payload = try store_cone.serialize(gpa);
        defer gpa.free(cone_payload);
        try checkout.updateSections(io, sparse.dir, &.{.{ .tag = .cone, .payload = cone_payload }});
        zit.repocache.writeStoreCone(gpa, io, sparse.dir, &store_cone);
        try writeFile(io, sparse.dir, "src/a", "edited\n");

        if (case == .corrupt_sibling or case == .shunned_sibling) {
            const bad = try appendArtifact(gpa, io, sparse.dir, tools_leaf);
            gpa.free(bad);
        }
        if (case == .shunned_sibling) {
            var digest: [32]u8 = undefined;
            _ = try std.fmt.hexToBytes(&digest, tools_hash);
            try shunDigestInRepo(gpa, io, sparse.dir, &digest);
        }
        if (complete_peer or case == .shunned_sibling) {
            const got = try appendArtifact(gpa, io, source.dir, tools_leaf);
            defer gpa.free(got);
            try std.testing.expectEqualStrings(tools_hash, got);
            const blob = try appendArtifact(gpa, io, source.dir, "tools/b");
            defer gpa.free(blob);
        }
        const port = try freshLoopbackPort(io);
        var server: ?std.process.Child = null;
        defer if (server) |*s| s.kill(io);
        if (complete_peer or case == .incomplete_peer or case == .shunned_sibling) {
            server = try spawnServe(gpa, io, source.dir, port);
            try waitForListen(io, port);
            const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
            defer gpa.free(url);
            var remote = try runZit(gpa, io, sparse.dir, &.{ "remote", url });
            defer freeResult(gpa, &remote);
            try expectExitDiag(remote.term, 0, remote);
        }
        const before = try readFile(gpa, io, sparse.dir, ".zit");
        defer gpa.free(before);
        const checkout_before = try readFile(gpa, io, sparse.dir, ".zit-checkout");
        defer gpa.free(checkout_before);
        if (complete_peer) {
            var preview = try runZit(gpa, io, sparse.dir, &.{ "commit", "--no-sync", "--dry-run", "--user", "e2e" });
            defer freeResult(gpa, &preview);
            try expectExitDiag(preview.term, 1, preview);
            try std.testing.expect(std.mem.indexOf(u8, preview.stderr, "before a dry-run commit") != null);
            try expectFileContent(gpa, io, sparse.dir, ".zit", before);
            try expectFileContent(gpa, io, sparse.dir, ".zit-checkout", checkout_before);
        }
        var committed = try runZit(gpa, io, sparse.dir, &.{ "commit", "--no-sync", "-m", "edit", "--user", "e2e" });
        defer freeResult(gpa, &committed);
        if (!complete_peer) {
            try expectExitDiag(committed.term, 1, committed);
            try expectCheckout(io, sparse.dir, base, "trunk");
            try expectFileContent(gpa, io, sparse.dir, "src/a", "edited\n");
            const checkout_after = try readFile(gpa, io, sparse.dir, ".zit-checkout");
            defer gpa.free(checkout_after);
            try std.testing.expectEqualSlices(u8, checkout_before, checkout_after);
            if (case == .no_remote or case == .corrupt_sibling or case == .shunned_sibling) {
                const after = try readFile(gpa, io, sparse.dir, ".zit");
                defer gpa.free(after);
                try std.testing.expectEqualSlices(u8, before, after);
            }
            if (case == .no_remote) {
                try std.testing.expect(std.mem.indexOf(u8, committed.stderr, "sparse cone and no remote") != null);
            } else if (case == .incomplete_peer) {
                try std.testing.expect(std.mem.indexOf(u8, committed.stderr, "required structural content") != null);
                try std.testing.expect(std.mem.indexOf(u8, committed.stderr, "refusing to commit") != null);
                try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, committed.stderr, "fetching required structural"));
            } else {
                try std.testing.expect(std.mem.indexOf(u8, committed.stderr, "parent check-in is corrupt") != null);
                try std.testing.expect(std.mem.indexOf(u8, committed.stderr, "fetching required") == null);
            }
        } else {
            try expectExitDiag(committed.term, 0, committed);
            try std.testing.expect(std.mem.indexOf(u8, committed.stderr, "fetching required structural") != null);
            _ = try checkinHash(committed.stdout);
            var retained = zit.repocache.readStoreCone(gpa, io, sparse.dir).?;
            defer retained.deinit(gpa);
            try std.testing.expect(retained.covers("src/a"));
            try std.testing.expect(!retained.covers("tools/b"));
            try std.testing.expect(!fileExists(io, sparse.dir, "tools/b"));
            var dense = std.testing.tmpDir(.{});
            defer dense.cleanup();
            try initRepo(gpa, io, dense.dir);
            try adoptStore(gpa, io, source.dir, dense.dir);
            var dense_open = try runZit(gpa, io, dense.dir, &.{"open"});
            defer freeResult(gpa, &dense_open);
            try expectExitDiag(dense_open.term, 0, dense_open);
            try writeFile(io, dense.dir, "src/a", "edited\n");
            var dense_commit = try runZit(gpa, io, dense.dir, &.{ "commit", "--no-sync", "-m", "edit", "--user", "e2e" });
            defer freeResult(gpa, &dense_commit);
            try expectExitDiag(dense_commit.term, 0, dense_commit);
            var dense_ls = try runZit(gpa, io, dense.dir, &.{ "ls", "--long" });
            defer freeResult(gpa, &dense_ls);
            var sparse_ls = try runZit(gpa, io, sparse.dir, &.{ "ls", "--long" });
            defer freeResult(gpa, &sparse_ls);
            try expectExitDiag(dense_ls.term, 0, dense_ls);
            try expectExitDiag(sparse_ls.term, 0, sparse_ls);
            try std.testing.expect(std.mem.indexOf(u8, sparse_ls.stdout, "tools/b") != null);
            const dense_tip = try checkoutVersionAlloc(gpa, io, dense.dir);
            defer gpa.free(dense_tip);
            const sparse_tip = try checkoutVersionAlloc(gpa, io, sparse.dir);
            defer gpa.free(sparse_tip);
            var dense_tree = try parseCheckin(gpa, io, dense.dir, dense_tip);
            defer dense_tree.deinit();
            var sparse_tree = try parseCheckin(gpa, io, sparse.dir, sparse_tip);
            defer sparse_tree.deinit();
            try std.testing.expectEqualDeep(dense_tree.m.s, sparse_tree.m.s);
            try std.testing.expectEqualDeep(dense_tree.m.f, sparse_tree.m.f);
            const blob_hash = try sha3HexAlloc(gpa, "tools/b");
            defer gpa.free(blob_hash);
            var elided = try runZit(gpa, io, sparse.dir, &.{ "artifact", blob_hash });
            defer freeResult(gpa, &elided);
            try expectExitDiag(elided.term, 1, elided);
        }
    }
}

test "cli sparse cone P6: the keystone holds on a submanifest-enabled repository" {
    // Goal: the tree-dialect half of reader-indistinguishability (RFC 4.2).
    // Same shape as the P5 keystone, but the source repo emits S-card tree
    // manifests, so the sparse commit's composed F-set drives the tree
    // construction and untouched out-of-cone subtrees reproduce their node
    // hashes by construction over the dense store. Method: enable
    // sub-manifests before the base commit, then dense-vs-sparse the same
    // change and byte-compare the enumerated file sets.
    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);
    var en = try runZit(gpa, io, tmp_a.dir, &.{ "submanifest", "enable", "--k", "3" });
    defer freeResult(gpa, &en);
    try expectExitDiag(en.term, 0, en);
    try tmp_a.dir.createDir(io, "src", .default_dir);
    try tmp_a.dir.createDir(io, "tools", .default_dir);
    try writeFile(io, tmp_a.dir, "src/a.zig", "a v1\n");
    try writeFile(io, tmp_a.dir, "tools/t.sh", "tool\n");
    try writeFile(io, tmp_a.dir, "README", "readme\n");
    try addManaged(gpa, io, tmp_a.dir, &.{ "src/a.zig", "tools/t.sh", "README" });
    const base = try commitHashDup(gpa, io, tmp_a.dir, "base");
    defer gpa.free(base);

    var dense = std.testing.tmpDir(.{});
    defer dense.cleanup();
    try initRepo(gpa, io, dense.dir);
    try adoptStore(gpa, io, tmp_a.dir, dense.dir);
    var od = try runZit(gpa, io, dense.dir, &.{"open"});
    defer freeResult(gpa, &od);
    try expectExitDiag(od.term, 0, od);
    try writeFile(io, dense.dir, "src/a.zig", "a v2\n");
    var cd = try runZit(gpa, io, dense.dir, &.{ "commit", "-m", "edit", "--user", "e2e" });
    defer freeResult(gpa, &cd);
    try expectExitDiag(cd.term, 0, cd);

    var sparse = std.testing.tmpDir(.{});
    defer sparse.cleanup();
    try initRepo(gpa, io, sparse.dir);
    try adoptStore(gpa, io, tmp_a.dir, sparse.dir);
    var os_ = try runZit(gpa, io, sparse.dir, &.{ "open", "--cone=src" });
    defer freeResult(gpa, &os_);
    try expectExitDiag(os_.term, 0, os_);
    try writeFile(io, sparse.dir, "src/a.zig", "a v2\n");
    var cs = try runZit(gpa, io, sparse.dir, &.{ "commit", "-m", "edit", "--user", "e2e" });
    defer freeResult(gpa, &cs);
    try expectExitDiag(cs.term, 0, cs);

    var ls_dense = try runZit(gpa, io, dense.dir, &.{"ls"});
    defer freeResult(gpa, &ls_dense);
    try expectExitDiag(ls_dense.term, 0, ls_dense);
    var ls_sparse = try runZit(gpa, io, sparse.dir, &.{"ls"});
    defer freeResult(gpa, &ls_sparse);
    try expectExitDiag(ls_sparse.term, 0, ls_sparse);
    try std.testing.expectEqualStrings(ls_dense.stdout, ls_sparse.stdout);
    try std.testing.expect(std.mem.indexOf(u8, ls_sparse.stdout, "tools/t.sh") != null);

    var ver = try runZit(gpa, io, sparse.dir, &.{"verify"});
    defer freeResult(gpa, &ver);
    try expectExitDiag(ver.term, 0, ver);
}

test "cli sparse cone exclusions: open --cone-not carves a subtree out, re-inclusion survives" {
    // Goal: section 3.2 exclusions end to end over the local surface: an
    // excluded subtree neither materializes nor tracks; a deeper
    // re-inclusion under the exclusion does; `zit cone` shows the exclusion
    // in the cone-file grammar; a dead exclusion refuses with the rule.
    // Method: adopt a store, open with --cone/--cone-not, probe the tree.
    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, "src/vendor", .default_dir);
    try tmp_a.dir.createDir(io, "src/vendor/keep", .default_dir);
    try writeFile(io, tmp_a.dir, "src/a.zig", "a\n");
    try writeFile(io, tmp_a.dir, "src/vendor/big.bin", "vendored\n");
    try writeFile(io, tmp_a.dir, "src/vendor/keep/gem.txt", "kept\n");
    try addManaged(gpa, io, tmp_a.dir, &.{ "src/a.zig", "src/vendor/big.bin", "src/vendor/keep/gem.txt" });
    const head = try commitHashDup(gpa, io, tmp_a.dir, "base");
    defer gpa.free(head);

    var tmp_b = std.testing.tmpDir(.{});
    defer tmp_b.cleanup();
    try initRepo(gpa, io, tmp_b.dir);
    try adoptStore(gpa, io, tmp_a.dir, tmp_b.dir);

    var opened = try runZit(gpa, io, tmp_b.dir, &.{
        "open", "--cone=src", "--cone-not=src/vendor", "--cone=src/vendor/keep",
    });
    defer freeResult(gpa, &opened);
    try expectExitDiag(opened.term, 0, opened);
    try expectCheckoutVersion(io, tmp_b.dir, head);

    // Positive space: the inclusion and the re-inclusion. Negative space:
    // the excluded interior.
    try std.testing.expect(fileExists(io, tmp_b.dir, "src/a.zig"));
    try std.testing.expect(fileExists(io, tmp_b.dir, "src/vendor/keep/gem.txt"));
    try std.testing.expect(!fileExists(io, tmp_b.dir, "src/vendor/big.bin"));

    // The cone verb prints exclusions in the cone-file grammar.
    var show = try runZit(gpa, io, tmp_b.dir, &.{"cone"});
    defer freeResult(gpa, &show);
    try expectExitDiag(show.term, 0, show);
    try std.testing.expectEqualStrings("src\nsrc/vendor/keep\n!src/vendor\n", show.stdout);

    // The excluded file is not an extra when it appears on disk, and a
    // commit round-trip keeps it in the record (reader indistinguishability
    // extends to exclusion boundaries).
    try writeFile(io, tmp_b.dir, "src/b.zig", "b\n");
    var ad = try runZit(gpa, io, tmp_b.dir, &.{ "add", "src/b.zig" });
    defer freeResult(gpa, &ad);
    try expectExitDiag(ad.term, 0, ad);
    var c2 = try runCommitEnv(gpa, io, tmp_b.dir, .{ .user = "u" }, &.{ "commit", "-m", "sparse add" });
    defer freeResult(gpa, &c2);
    try expectExit(c2.term, 0);
    var ls = try runZit(gpa, io, tmp_b.dir, &.{ "ls", "tip" });
    defer freeResult(gpa, &ls);
    try expectExitDiag(ls.term, 0, ls);
    try std.testing.expect(std.mem.indexOf(u8, ls.stdout, "src/vendor/big.bin") != null);
    try std.testing.expect(std.mem.indexOf(u8, ls.stdout, "src/b.zig") != null);

    // A dead exclusion refuses with the rule, not a guess.
    var tmp_c = std.testing.tmpDir(.{});
    defer tmp_c.cleanup();
    try initRepo(gpa, io, tmp_c.dir);
    try adoptStore(gpa, io, tmp_a.dir, tmp_c.dir);
    var dead = try runZit(gpa, io, tmp_c.dir, &.{ "open", "--cone=src", "--cone-not=tools" });
    defer freeResult(gpa, &dead);
    try expectExit(dead.term, 1);
    try std.testing.expect(std.mem.indexOf(u8, dead.stderr, "dead rule") != null);
}