"""Scenario sources: vendored gitoxide baselines, suite-authored scenarios, generated histories.

A scenario is a dict:

  id, version, origin, upstream{id, license, commit?}, repo (git repo Path),

  directions: [{name, plan (see oak_adapter.run_pull_sync), oracle{ours, theirs},

                trees{base, ours, theirs}, expect?, intent_note?}],

  unsupported: reason | None, notes

"""

from __future__ import annotations

import os

from pathlib import Path

import random

import subprocess

from typing import Dict, List, Optional

from .builder import RepoBuilder, lines

from .gitops import Git, git_env, sha256

VENDOR = Path(__file__).resolve().parents[1] / "vendor" / "gitoxide"

GITOXIDE_COMMIT = "acf906f8fcdb8e8d143570737786543dc5a204a0"

GITOXIDE_LICENSE = "MIT OR Apache-2.0"

GIT_TESTS_REF = "git v2.50.1 (d82adb61ba2fd11d8f2587fca1b6bd7925ce4044) t/ comment prose; re-implemented, GPL text not copied"

# --------------------------------------------------------------------------- helpers

def three_way(git: Git, ours: str, theirs: str) -> dict:

    """Directional plan for a plain 3-way case: main=theirs, branch=fork(base)+ours tree."""

    bases = git.merge_bases(ours, theirs)

    base = bases[0] if len(bases) == 1 else None

    return {

        "plan": {"main": theirs, "fork": base, "steps": [{"op": "commit", "tree": ours}]},

        "oracle": {"ours": ours, "theirs": theirs},

        "trees": {"base": base, "ours": ours, "theirs": theirs},

        "merge_bases": bases,

    }

def unsupported_reason(git: Git, direction: dict) -> Optional[str]:

    bases = direction["merge_bases"]

    if not bases:

        return "unrelated histories: Oak branches always fork from a main commit"

    if len(bases) > 1:

        return ("multiple git merge bases: the ours side would need merge commits, which the "

                "fork+checkpoint construction cannot import (criss-cross is covered by staged native scenarios)")

    for key in ("base", "ours", "theirs"):

        mode_lines = git.out("ls-tree", "-r", "--full-tree", direction["trees"][key])

        if any(line.startswith("160000 ") for line in mode_lines.splitlines()):

            return "gitlink (submodule) entries: Oak's git import drops gitlinks"

    return None

def symmetric(scenario_id: str, origin: str, upstream: dict, git: Git, a: str, b: str,

              names=("A-B", "B-A"), notes: str = "", expect: Optional[dict] = None) -> dict:

    directions = []

    for name, (ours, theirs) in zip(names, ((a, b), (b, a))):

        d = three_way(git, ours, theirs)

        d["name"] = name

        if expect:

            d["expect"] = expect

        directions.append(d)

    reason = unsupported_reason(git, directions[0])

    return {"id": scenario_id, "version": 1, "origin": origin, "upstream": upstream,

            "repo": git.repo, "directions": directions, "unsupported": reason, "notes": notes}

def _run_vendored(script: str, workdir: Path, git_bin: str, home: Path) -> Path:

    out = workdir / "gitoxide" / script.replace(".sh", "")

    marker = out / ".mergesuite-complete"

    if marker.exists():

        return out

    out.mkdir(parents=True, exist_ok=True)

    env = git_env(home)

    for k in ("GIT_AUTHOR_DATE", "GIT_COMMITTER_DATE"):

        env.pop(k)  # the scripts `tick` their own dates

    env["PATH"] = str(Path(git_bin).parent) + os.pathsep + env.get("PATH", "")

    p = subprocess.run(["bash", str(VENDOR / script)], cwd=out, env=env, capture_output=True, timeout=900)

    (out / "script.log").write_bytes(p.stdout[-20000:] + p.stderr[-20000:])

    if p.returncode:

        raise RuntimeError(f"vendored {script} failed rc={p.returncode}; see {out / 'script.log'}")

    marker.write_text("ok\n")

    return out

# --------------------------------------------------------------------------- gitoxide

def gitoxide_tree(workdir: Path, git_bin: str, home: Path) -> List[dict]:

    root = _run_vendored("tree-baseline.sh", workdir, git_bin, home)

    seen, scenarios = set(), []

    for line in (root / "baseline.cases").read_text().splitlines():

        parts = line.split(" ")

        directory, style, _oc, ours_ref, _tc, theirs_ref, merge_info = parts[:7]

        if style != "merge":

            continue  # diff3 duplicates differ only in marker text; Oak has one marker style

        name = merge_info.replace(".merge-info", "").replace("-reversed", "")

        key = (directory, name)

        if key in seen:

            continue

        seen.add(key)

        git = Git(root / directory, git_bin, home)

        a, b = git.rev(ours_ref), git.rev(theirs_ref)

        deviation = " ".join(parts[8:]).strip()

        scenarios.append(symmetric(

            f"gix-tree/{directory}/{name}", "gitoxide-tree-baseline",

            {"id": f"gix-merge tree-baseline.sh {directory} {name}", "license": GITOXIDE_LICENSE,

             "commit": GITOXIDE_COMMIT}, git, a, b,

            names=(f"{ours_ref}-{theirs_ref}", f"{theirs_ref}-{ours_ref}"),

            notes=("gitoxide deviation note: " + deviation) if deviation else ""))

    return scenarios

def gitoxide_cartesian(workdir: Path, git_bin: str, home: Path, include_submodule: bool = True) -> List[dict]:

    root = _run_vendored("tree-cartesian-baseline.sh", workdir, git_bin, home)

    scenarios = []

    for matrix in ("matrix", "matrix-submodule") if include_submodule else ("matrix",):

        git = Git(root / matrix, git_bin, home)

        for line in (root / matrix / "cases.tsv").read_text().splitlines():

            left, right, a, b = line.split("\t")[:4]

            scenarios.append(symmetric(

                f"gix-cartesian/{matrix}/{left}--{right}", "gitoxide-cartesian",

                {"id": f"gix-merge tree-cartesian-baseline.sh {matrix} {left}--{right}",

                 "license": GITOXIDE_LICENSE, "commit": GITOXIDE_COMMIT}, git, a, b))

    return scenarios

def gitoxide_text(workdir: Path, git_bin: str, home: Path) -> List[dict]:

    """Each blob triple becomes a one-file tree merge (default marker style only)."""

    root = _run_vendored("text-baseline.sh", workdir, git_bin, home)

    repo_dir = workdir / "gitoxide" / "text-trees"

    scenarios = []

    builder = None

    for line in (root / "baseline.cases").read_text().splitlines():

        parts = line.split(" ")

        ours_blob, base_blob, theirs_blob, output = parts[:4]

        if not output.endswith("/merge.merged") or len(parts) > 4:

            continue

        case = output[:-len("/merge.merged")]

        if builder is None:

            builder = RepoBuilder(repo_dir, git_bin, home)

        data = {k: (root / p).read_bytes() for k, p in

                (("base", base_blob), ("ours", ours_blob), ("theirs", theirs_blob))}

        base = builder.commit({"file": data["base"]}, message=f"{case} base")

        a = builder.commit({"file": data["ours"]}, [base], message=f"{case} ours")

        b = builder.commit({"file": data["theirs"]}, [base], message=f"{case} theirs")

        scenarios.append(symmetric(

            f"gix-text/{case}", "gitoxide-text-baseline",

            {"id": f"gix-merge text-baseline.sh {case} merge", "license": GITOXIDE_LICENSE,

             "commit": GITOXIDE_COMMIT}, builder, a, b, names=("ours-theirs", "theirs-ours")))

    return scenarios

# --------------------------------------------------------------------------- git t64xx (re-implemented)

def _c(name: str, variant: str = "") -> bytes:

    """Distinct 6-line content per logical file (similar enough for rename detection)."""

    body = [f"{name} line {i}" for i in range(1, 7)]

    if variant == "top":

        body[0] += " (edited top)"

    elif variant == "bottom":

        body[-1] += " (edited bottom)"

    elif variant == "alt":

        body = [f"{name} alternative {i}" for i in range(1, 7)]

    return lines(*body)

def _tree(spec: Dict[str, str]) -> Dict[str, bytes]:

    """{path: logical-name[:variant]} -> {path: content}."""

    out = {}

    for path, logical in spec.items():

        name, _, variant = logical.partition(":")

        out[path] = _c(name, variant)

    return out

def _d(prefix: str, names: str, **variants) -> Dict[str, str]:

    """_d("z", "b c d") -> {"z/b": "b", ...}; variants map name->logical override."""

    return {f"{prefix}/{n}": variants.get(n, n) for n in names.split()}

def _u(*dicts) -> Dict[str, str]:

    out = {}

    for d in dicts:

        out.update(d)

    return out

# (id, O, A, B). Shapes re-expressed from the testcase comment prose; content is ours.

T64XX = [

    ("git-t6423-1a", _d("z", "b c"), _d("y", "b c"), _u(_d("z", "b c d"), {"z/e/f": "f"})),

    ("git-t6423-1b", _u(_d("z", "b c"), _d("y", "d")), _u(_d("z", "b c e"), _d("y", "d")), _d("y", "b c d")),

    ("git-t6423-1c", _u(_d("z", "b c"), _d("x", "d")), _u(_d("y", "b c"), _d("x", "d")), _d("z", "b c d")),

    ("git-t6423-1f", _d("z", "b c d e f"), _d("z", "b c d e f g"), _u(_d("y", "b c"), _d("x", "d e f"))),

    ("git-t6423-2a", _d("z", "b c"), {"y/b": "b", "w/c": "c"}, _d("z", "b c d")),

    ("git-t6423-3a", _d("z", "b c d"), _d("z", "b c d"), _u(_d("y", "b c"), _d("x", "d"))),

    ("git-t6423-4a", _d("z", "b c d e"), _u(_d("y", "b c d"), _d("z", "e")), _d("z", "b c d e f")),

    ("git-t6423-5a", _u(_d("z", "b c"), _d("y", "d")),

     _u(_d("z", "b c f"), {"z/e": "e1"}, _d("y", "d"), {"y/e": "e2"}), _d("y", "b c d")),

    ("git-t6423-6a", _d("z", "b c d"), _d("z", "b"), _u(_d("y", "b c"), _d("z", "d"))),

    ("git-t6423-6c", _d("z", "b c"), _d("z", "b c"), _u(_d("y", "b c"), _d("z", "d"))),

    ("git-t6423-6d", _u(_d("z", "b c"), _d("x", "d")), _u(_d("z", "b c"), _d("x", "d")), _u(_d("y", "b c"), _d("z", "d"))),

    ("git-t6423-7a", _d("z", "b c"), _d("y", "b c"), {"w/b": "b", "x/c": "c", "z/d": "d"}),

    ("git-t6423-8c", _d("z", "b c d"), _d("y", "b c"), _d("z", "b c d e", d="d:bottom")),

    ("git-t6423-9a", _u(_d("z", "b c"), _d("z/d", "e f g")), _u(_d("y", "b c"), _d("x/w", "e f g")),

     _u(_d("z", "b c i"), _d("z/d", "e f g h"))),

    ("git-t6423-9b", _u(_d("z", "b c"), _d("x", "d")), _u(_d("y", "b c"), _d("x", "d", d="d:top")),

     _d("z", "b c d", d="d:bottom")),

    ("git-t6423-12d", {"a/b/subdir/foo": "foo"}, {"subdir/foo": "foo"}, {"a/b/subdir/foo": "foo", "a/b/bar": "bar"}),

    ("git-t6423-12i", {"source/subdir/foo": "foo", "source/bar": "bar", "source/baz": "baz"},

     {"source/foo": "foo", "source/bar": "bar", "source/baz": "baz"},

     {"source/subdir/foo": "foo", "source/subdir/bar": "bar", "source/baz": "baz:bottom"}),

]

def git_t64xx(workdir: Path, git_bin: str, home: Path) -> List[dict]:

    scenarios = []

    for sid, o, a, b in T64XX:

        builder = RepoBuilder(workdir / "t64xx" / sid, git_bin, home)

        base = builder.commit(_tree(o), message=f"{sid} O")

        ca = builder.commit(_tree(a), [base], message=f"{sid} A")

        cb = builder.commit(_tree(b), [base], message=f"{sid} B")

        scenarios.append(symmetric(sid, "git-t64xx-reimplemented",

                                   {"id": sid, "license": "scenario idea only (source GPL-2.0-only)",

                                    "commit": GIT_TESTS_REF}, builder, ca, cb))

    # t6422 corner cases (break detection / binary rename), content authored here.

    five = lines("1", "2", "3", "4", "5")

    extra = [

        ("git-t6422-break-detection-1", {"a": five, "b": lines("foo")},

         {"c": five, "a": lines("Completely different content"), "b": lines("foo")},

         {"a": five + lines("6"), "b": lines("foo")}),

        ("git-t6422-break-detection-2", {"a": five, "b": lines("foo")},

         {"c": five + lines("7"), "a": lines("Completely different content"), "b": lines("foo")},

         {"a": lines("Completely different content"), "b": lines("foo")}),

        ("git-t6422-break-detection-3", {"a": five}, {"b": five}, {"b": five, "a": lines("foobar")}),

        ("git-t6422-rename-rename-1to2-binary", {"a": bytes(range(256)) * 4},

         {"b": bytes(range(256)) * 4}, {"c": bytes(range(256)) * 4}),

    ]

    for sid, o, a, b in extra:

        builder = RepoBuilder(workdir / "t64xx" / sid, git_bin, home)

        base = builder.commit(o, message=f"{sid} O")

        ca = builder.commit(a, [base], message=f"{sid} A")

        cb = builder.commit(b, [base], message=f"{sid} B")

        scenarios.append(symmetric(sid, "git-t64xx-reimplemented",

                                   {"id": sid, "license": "scenario idea only (source GPL-2.0-only)",

                                    "commit": GIT_TESTS_REF}, builder, ca, cb))

    return scenarios

# --------------------------------------------------------------------------- native incident shapes

F0 = lines("l1", "l2", "l3", "l4", "l5")

FX = lines("l1", "l2 X", "l3", "l4", "l5")

FK = lines("l1", "l2 K", "l3", "l4", "l5")

def _staged(sid: str, builder: RepoBuilder, plan: dict, oracle_ours: str, oracle_theirs: str,

            expect: dict, upstream: dict, notes: str, intent_note: str = "") -> dict:

    bases = builder.merge_bases(oracle_ours, oracle_theirs)

    direction = {"name": "branch-into-main-sync", "plan": plan,

                 "oracle": {"ours": oracle_ours, "theirs": oracle_theirs},

                 "trees": {"base": bases[0] if len(bases) == 1 else None, "ours": oracle_ours,

                           "theirs": oracle_theirs},

                 "merge_bases": bases, "expect": expect}

    if intent_note:

        direction["intent_note"] = intent_note

    return {"id": sid, "version": 1, "origin": "native-incident", "upstream": upstream,

            "repo": builder.repo, "directions": [direction], "unsupported": None, "notes": notes,

            "staged": True}

def native_incidents(workdir: Path, git_bin: str, home: Path) -> List[dict]:

    out = []

    seed = {"id": "oak cli/src/commands/merge/merge_base_fixtures.rs squash_revert (5d2ee0fb)",

            "license": "suite-authored"}

    repro = {"id": "worker-mrmrs-20260926T092526-repro-server-mergebase REPRO.md", "license": "suite-authored"}

    # N1: stale base C vs correct X; ours clone holds only R-C-X locally (partial graph),

    # the rest of main (M1..M9, Z1, H) is hydrated during pull.

    b = RepoBuilder(workdir / "native" / "stale-base", git_bin, home)

    files = {"f.txt": F0, "r.txt": lines("r")}

    r = b.commit(files, message="R")

    files = dict(files, **{"c.txt": lines("c")})

    c = b.commit(files, [r], message="C")

    x = b.commit(dict(files, **{"f.txt": FX}), [c], message="X")

    main_files, prev = dict(files, **{"f.txt": FX}), x

    for i in range(1, 10):

        main_files = dict(main_files, **{f"m{i}.txt": lines(f"m{i}")})

        if i == 5:

            main_files["f.txt"] = F0  # M5 reverts X

        prev = b.commit(main_files, [prev], message=f"M{i}")

    z1 = b.commit(dict(files, **{"z.txt": lines("z1", "z2", "z3")}), [c], message="Z1")

    h = b.commit(dict(main_files, **{"z.txt": lines("z1", "z2", "z3")}), [prev, z1], message="H")

    a1 = b.commit(dict(files, **{"f.txt": FX, "a.txt": lines("a")}), [x], message="a1")

    out.append(_staged("incident/stale-base-squash-revert", b,

                       {"main": h, "fork": x, "steps": [{"op": "commit", "tree": a1}]}, a1, h,

                       {"clean": True, "paths": {"f.txt": sha256(F0), "a.txt": sha256(lines("a"))}},

                       seed, "True base X; stale base C would resurrect X (reverted by M5)."))

    # N1b: fork from the side commit Z1 (reachable only through H's merge parent).

    h2 = b.commit(dict(main_files, **{"z.txt": lines("z1", "z2", "z3 main")}), [h], message="H2")

    oz = b.commit(dict(files, **{"z.txt": lines("z1 ours", "z2", "z3")}), [z1], message="oz")

    out.append(_staged("incident/merge-base-via-merge-parent", b,

                       {"main": h2, "fork": z1, "steps": [{"op": "commit", "tree": oz}]}, oz, h2,

                       {"clean": True, "paths": {"z.txt": sha256(lines("z1 ours", "z2", "z3 main")),

                                                 "f.txt": sha256(F0)}},

                       seed, "Base is Z1 (reached via H.merge_parent); a stale base (C) makes z.txt add/add."))

    # N2: revert after a CLI parent sync (lineage recorded by the sync commit).

    b = RepoBuilder(workdir / "native" / "revert-after-sync", git_bin, home)

    c0 = b.commit({"f.txt": F0}, message="C0")

    f1 = b.commit({"f.txt": F0, "feat.txt": lines("feat")}, [c0], message="F1")

    m1 = b.commit({"f.txt": FX}, [c0], message="M1 adds X")

    m2 = b.commit({"f.txt": F0}, [m1], message="M2 reverts X")

    s = b.commit({"f.txt": FX, "feat.txt": lines("feat")}, [f1, m1], message="S sync")

    out.append(_staged("incident/revert-after-client-sync", b,

                       {"main": m2, "fork": c0, "steps": [{"op": "commit", "tree": f1},

                                                          {"op": "pull", "stage": m1}]}, s, m2,

                       {"clean": True, "paths": {"f.txt": sha256(F0), "feat.txt": sha256(lines("feat"))}},

                       repro, "Client pull-sync must record merge_parent=M1 so M2's revert survives."))

    # N2b: lineage-less sync (manual copy of main's change; the server /sync shape).

    s0 = b.commit({"f.txt": FX, "feat.txt": lines("feat")}, [f1], message="S0 lineage-less")

    out.append(_staged("incident/revert-after-lineage-less-sync", b,

                       {"main": m2, "fork": c0, "steps": [{"op": "commit", "tree": f1},

                                                          {"op": "commit", "tree": s0}]}, s0, m2,

                       {"clean": True}, repro,

                       "History without the sync's merge parent: git and Oak both resurrect X.",

                       intent_note=("Intent is 'revert stays reverted', but once lineage is lost no merge "

                                    "can recover it; hosted POST /sync producing this shape is phase-2 "

                                    "(REPRO.md Suspect 1).")))

    # N3: criss-cross with two best common ancestors {F, Mk}; tie-break must not resurrect K.

    for variant, f_when, mk_when in (("side-newer", 300, 120), ("side-older", 60, 300)):

        b = RepoBuilder(workdir / "native" / f"criss-cross-{variant}", git_bin, home)

        base = b.commit({"f.txt": F0}, message="C", when=0)

        mk = b.commit({"f.txt": FK}, [base], message="Mk adds K", when=mk_when)

        fside = b.commit({"f.txt": F0, "side.txt": lines("side")}, [base], message="F side", when=f_when)

        hmerge = b.commit({"f.txt": FK, "side.txt": lines("side")}, [mk, fside], message="H merges F", when=400)

        rev = b.commit({"f.txt": F0, "side.txt": lines("side")}, [hmerge], message="R reverts K", when=500)

        o1 = b.commit({"f.txt": F0, "side.txt": lines("side"), "ours.txt": lines("o")}, [fside], message="o1", when=450)

        s1 = b.commit({"f.txt": FK, "side.txt": lines("side"), "ours.txt": lines("o")}, [o1, mk], message="S1 sync", when=460)

        out.append(_staged(f"incident/criss-cross-tie-break-{variant}", b,

                           {"main": rev, "fork": fside, "steps": [{"op": "commit", "tree": o1},

                                                                  {"op": "pull", "stage": mk}]}, s1, rev,

                           {"clean": True, "paths": {"f.txt": sha256(F0), "ours.txt": sha256(lines("o"))}},

                           repro, "Best common ancestors {F, Mk}; choosing F alone resurrects K."))

    # N4: clock skew (REPRO.md s2): Y is the best CA but 24h older than X.

    for variant, y_when in (("skewed", -86400), ("monotone-control", 30)):

        b = RepoBuilder(workdir / "native" / f"clock-skew-{variant}", git_bin, home)

        x = b.commit({"f.txt": F0}, message="X", when=0)

        y = b.commit({"f.txt": FX}, [x], message="Y", when=y_when)

        h1 = b.commit({"f.txt": F0, "h.txt": lines("h")}, [x], message="H1", when=3600)

        mh = b.commit({"f.txt": FX, "h.txt": lines("h")}, [y, h1], message="M_h", when=3 * 3600)

        rr = b.commit({"f.txt": F0, "h.txt": lines("h")}, [mh], message="R reverts Y", when=5 * 3600)

        w = b.commit({"f.txt": F0, "feat.txt": lines("feat")}, [x], message="W", when=2 * 3600)

        a = b.commit({"f.txt": FX, "feat.txt": lines("feat")}, [w, y], message="A sync", when=4 * 3600)

        out.append(_staged(f"incident/clock-skew-merge-base-{variant}", b,

                           {"main": rr, "fork": x, "steps": [{"op": "commit", "tree": w},

                                                             {"op": "pull", "stage": y}]}, a, rr,

                           {"clean": True, "paths": {"f.txt": sha256(F0), "feat.txt": sha256(lines("feat"))}},

                           repro, "Best CA Y has an older timestamp than X; a time-ordered walk picks X."))

    # t6416 criss-cross + modify/delete resolved differently (staged with a scripted resolution).

    b = RepoBuilder(workdir / "native" / "t6416-criss-cross-modify-delete", git_bin, home)

    ca = b.commit({"file": lines("A"), "keep": lines("k")}, message="A")

    cb = b.commit({"file": lines("B"), "keep": lines("k")}, [ca], message="B")

    cc = b.commit({"keep": lines("k")}, [ca], message="C")

    cd = b.commit({"file": lines("B"), "keep": lines("k")}, [cc, cb], message="D keeps B")

    o1 = b.commit({"file": lines("B"), "keep": lines("k"), "ours.txt": lines("o")}, [cb], message="o1")

    ce = b.commit({"keep": lines("k"), "ours.txt": lines("o")}, [o1, cc], message="E deletes")

    out.append(_staged("git-t6416-criss-cross-modify-delete", b,

                       {"main": cd, "fork": cb, "steps": [{"op": "commit", "tree": o1},

                                                          {"op": "pull", "stage": cc, "resolve": {"file": None}}]},

                       ce, cd, {"clean": False},

                       {"id": "git-t6416 'criss-cross + modify/delete resolved differently'",

                        "license": "scenario idea only (source GPL-2.0-only)", "commit": GIT_TESTS_REF},

                       "Two histories resolved the same modify/delete differently; git reports a conflict."))

    return out

# --------------------------------------------------------------------------- generated (merge laws)

def generated(workdir: Path, git_bin: str, home: Path, count: int, seed: int) -> List[dict]:

    rng = random.Random(seed)

    out = []

    for n in range(count):

        builder = RepoBuilder(workdir / "generated" / f"g{seed}-{n:03d}", git_bin, home)

        base_files = {f"src/f{i}.txt": lines(*[f"f{i} line {k}" for k in range(12)]) for i in range(4)}

        base = builder.commit(base_files, message="base")

        region = {"A": range(0, 5), "B": range(7, 12)}

        sides = {}

        ops_log = {}

        shared_edit = rng.random() < 0.15

        for side in ("A", "B"):

            files = dict(base_files)

            ops = []

            for _ in range(rng.randint(1, 3)):

                op = rng.choice(["edit", "edit", "overlap", "delete", "add", "chmod", "rename"])

                target = rng.choice(sorted(p for p in files if p.startswith("src/")) or ["src/new.txt"])

                editable = target in files and not isinstance(files[target], tuple) \

                    and len(files[target].splitlines()) == 12

                if op in ("edit", "overlap") and editable:

                    body = files[target].decode().splitlines()

                    idx = 5 if op == "overlap" else rng.choice(list(region[side]))

                    body[idx] = body[idx] + f" [{side}{n}]"

                    files[target] = lines(*body)

                elif op == "delete" and target in files:

                    del files[target]

                elif op == "add":

                    files[f"src/{side.lower()}{n}-{len(ops)}.txt"] = lines(f"new {side} {n} {len(ops)}")

                elif op == "chmod" and target in files and not isinstance(files[target], tuple):

                    files[target] = ("exec", files[target])

                elif op == "rename" and target in files:

                    files[target.replace("src/", "moved/")] = files.pop(target)

                else:

                    continue

                ops.append(f"{op}:{target}")

            if shared_edit:

                files["shared.txt"] = lines("same change on both sides")

                ops.append("shared-add")

            sides[side] = builder.commit(files, [base], message=f"side {side}")

            ops_log[side] = ops

        out.append(symmetric(f"generated/s{seed}-{n:03d}", "generated-law",

                             {"id": f"seeded generator seed={seed} n={n}", "license": "suite-authored"},

                             builder, sides["A"], sides["B"], notes=f"ops={ops_log}"))

    return out

PHASE2_SPECS = [

    {"id": "phase2/concurrent-merges-one-target-M0a",

     "needs": "hosted merge endpoint (oakspace POST /branches/:b/merge)",

     "spec": "N branches each add a distinct file; concurrent merges to main. Every 200-acknowledged merge "

             "must be present in main's content and first-parent lineage; losers get a retryable refusal.",

     "source": "REPRO.md M0a"},

    {"id": "phase2/push-during-merge-M0b", "needs": "hosted merge endpoint",

     "spec": "Branch head a1 resolved; owner pushes a2 before finalize. Merge must include a2 or be refused; "

             "never close the branch with merge_parent=a2 while main lacks a2's change.",

     "source": "REPRO.md M0b"},

    {"id": "phase2/server-sync-lineage-less-S1", "needs": "hosted POST /branches/:b/sync",

     "spec": "Web 'Update' sync must record merge_parent=main head; after main reverts the synced change, "

             "merging the branch keeps the revert (see incident/revert-after-lineage-less-sync for the "

             "client-side consequence).", "source": "REPRO.md Suspect 1"},

    {"id": "phase2/criss-cross-client-vs-server-tie-break", "needs": "hosted merge + client prediction",

     "spec": "For incident/criss-cross-tie-break-* shapes, server merge result and client "

             "`oak merge --dry-run --json` prediction must agree and keep the revert.",

     "source": "REPRO.md 'Not executed: tie-break among multiple best CAs (M1)'"},

    {"id": "phase2/server-clock-skew-merge-base-S2", "needs": "hosted merge endpoint",

     "spec": "Server find_merge_base on the incident/clock-skew-merge-base-skewed shape must pick Y.",

     "source": "REPRO.md Suspect 2"},

    {"id": "phase2/dirty-tree-across-moved-branch-fb530", "needs": "client+server: branch head moved remotely",

     "spec": "Uncommitted edits survive `oak pull` when the branch head moved on the server; no silent discard.",

     "source": "PROGRAM.md coordination fb-530"},

]