@@ -30,6 +30,9 @@ alters no template carries no entry.
 - `tools/resolve.py` exits 1 naming a `depends_on` ID with no manifest
   entry and the entry naming it, or a dependency cycle as a path, where it
   used to resolve a shorter chain or crash.
+- Smoke check SYS-20 fails when a fork edits an upstream manifest key
+  (`core`, `base`, `backend`, `frontend`), naming the key and entry,
+  against the upstream revision it last merged, set by `SAIT_UPSTREAM_REF`.
 
 ### Breaking changes
 
 
@@ -427,6 +427,9 @@ Run `py tests/run_smoke.py` before every PR. It checks:
   exemption's recorded reason still holds (ADR-044)
 - SYS-19: `resolve.py` names a missing dependency and a dependency cycle,
   each with its own message and exit 1
+- SYS-20: a fork leaves the manifest's upstream keys (`core`, `base`,
+  `backend`, `frontend`) as it last merged them, against the ref in
+  `SAIT_UPSTREAM_REF`; upstream sets none and passes against itself
 - Prompt builds for all stacks
 
 ## 6. Session protocol
 
@@ -392,6 +392,18 @@ See `tests/CODIFICATION.md` for the ID scheme and `tests/INDEX.md` for the
 full list of specs. Requires `py -m pip install pyyaml` for the manifest
 check.
 
+In a fork, set `SAIT_UPSTREAM_REF` to a ref holding upstream's history
+before running smoke, so SYS-20 compares the manifest's upstream keys with
+the revision the fork last merged:
+
+```bash
+git fetch upstream
+SAIT_UPSTREAM_REF=upstream/main py tests/run_smoke.py SYS-20
+```
+
+Unset, SYS-20 treats the checkout as upstream and compares the manifest
+with itself.
+
 `run_e2e.py` is the one runner that calls a model and costs money, so it
 runs on a cadence rather than on every change: the STK-24 canary runs live
 at every release cut, recorded in the cut's pull request, and the full
 
@@ -41,6 +41,7 @@ restated in each.
 | `SAIT-SMK-SYS-17-001A` | SMK | P2 | Every registered check names a spec document that exists |
 | `SAIT-SMK-SYS-18-001A` | SMK | P1 | A stack outside the constrained categories resolves the gate tier |
 | `SAIT-SMK-SYS-19-001A` | SMK | P1 | resolve.py names a missing dependency and a dependency cycle |
+| `SAIT-SMK-SYS-20-001A` | SMK | P1 | A fork leaves upstream's manifest keys as it last merged them |
 | `SAIT-SMK-TPL-04-001A` | SMK | P1 | All EXTEND and OVERRIDE directives reference existing IDs |
 | `SAIT-INT-TPL-01-001A` | INT | P0 | DEPENDS ON chain assembles a complete rule set |
 | `SAIT-INT-TPL-02-001A` | INT | P1 | EXTEND adds rules without removing base rules |
 
@@ -2462,6 +2462,151 @@ def check_sys_19():
     return seen.failures() + failures, seen.notes()
 
 
+# ---------------------------------------------------------------------------
+# SYS-20 -- a fork leaves upstream's manifest keys as it last merged them
+# ---------------------------------------------------------------------------
+
+# A fork appends under `stacks:`, `platform:` and keys of its own, and never
+# edits the keys upstream owns. An edit there is what turns the fork's next
+# upstream merge into a conflict, and nothing else notices it until then.
+#
+# In a fork, SAIT_UPSTREAM_REF names a ref holding upstream's history, and
+# the baseline is the revision the fork last merged: the merge base of HEAD
+# and that ref. Upstream sets no ref, so the manifest is compared with
+# itself and the check passes trivially. Because that run reads no edit,
+# planted manifest pairs exercise the failing path on every run.
+
+UPSTREAM_KEYS = ("core", "base", "backend", "frontend")
+UPSTREAM_REF_ENV = "SAIT_UPSTREAM_REF"
+
+
+def upstream_key_edits(was, now):
+    """Each edit to an upstream-owned manifest key, as one finding."""
+    found = []
+    for key in UPSTREAM_KEYS:
+        before, after = was.get(key) or [], now.get(key) or []
+        if key == "core":
+            if before != after:
+                found.append(f"core: {before} became {after}")
+            continue
+        old = {e["id"]: e for e in before}
+        new = {e["id"]: e for e in after}
+        for eid in sorted(set(old) - set(new)):
+            found.append(f"{key}: {eid} removed")
+        for eid in sorted(set(new) - set(old)):
+            found.append(f"{key}: {eid} added")
+        for eid in sorted(set(old) & set(new)):
+            fields = sorted(k for k in set(old[eid]) | set(new[eid])
+                            if old[eid].get(k) != new[eid].get(k))
+            if fields:
+                found.append(f"{key}: {eid} changed ({', '.join(fields)})")
+    return found
+
+
+OWNED_BASE = """core: [base-a]
+base:
+  - id: base-a
+    file: templates/core/quality.md
+backend:
+  - id: backend-a
+    file: templates/backend/http.md
+    depends_on: [base-a]
+frontend: []
+stacks:
+  - id: stack-a
+    file: templates/stack/a.md
+    depends_on: [backend-a]
+"""
+
+# Each case is a fork's manifest against OWNED_BASE, and the findings the
+# check owes it. The appends are the control: a check that flagged them
+# would fail every fork that did what the contract allows.
+OWNERSHIP_CASES = [
+    ("a stack and a platform appended, and a key of the fork's own",
+     OWNED_BASE + """  - id: stack-b
+    file: templates/stack/b.md
+platform:
+  - id: platform-b
+    file: templates/platform/b.md
+fork:
+  - id: fork-note
+""", []),
+    ("the core tier edited",
+     OWNED_BASE.replace("core: [base-a]", "core: [base-a, backend-a]"),
+     ["core: ['base-a'] became ['base-a', 'backend-a']"]),
+    ("an upstream entry changed",
+     OWNED_BASE.replace("depends_on: [base-a]", "depends_on: []"),
+     ["backend: backend-a changed (depends_on)"]),
+    ("an entry added under an upstream key",
+     OWNED_BASE.replace("frontend: []", """frontend:
+  - id: frontend-b
+    file: templates/frontend/b.md"""),
+     ["frontend: frontend-b added"]),
+    ("an upstream entry removed",
+     OWNED_BASE.replace("""  - id: backend-a
+    file: templates/backend/http.md
+    depends_on: [base-a]
+""", ""),
+     ["backend: backend-a removed"]),
+]
+
+
+def check_sys_20():
+    if not HAS_YAML:
+        return [MISSING_YAML]
+
+    seen = Inspected()
+    failures = []
+
+    seen.count("planted fork manifests", OWNERSHIP_CASES)
+    base = yaml.safe_load(OWNED_BASE)
+    for label, text, want in OWNERSHIP_CASES:
+        got = upstream_key_edits(base, yaml.safe_load(text))
+        if got != want:
+            failures.append(f"  planted, {label}: found {got}, owed {want}")
+
+    manifest = os.path.join(ROOT, "templates", "manifest.yaml")
+    with io.open(manifest, encoding="utf-8") as handle:
+        now_text = handle.read()
+
+    ref = os.environ.get(UPSTREAM_REF_ENV)
+    if ref:
+        merged = subprocess.run(["git", "merge-base", "HEAD", ref],
+                                cwd=ROOT, capture_output=True, text=True)
+        if merged.returncode != 0:
+            failures.append(
+                f"  {UPSTREAM_REF_ENV}={ref} shares no history with HEAD, so "
+                f"the revision the fork last merged is unknown: "
+                f"{merged.stderr.strip()}"
+            )
+            return seen.failures() + failures, seen.notes()
+        revision = merged.stdout.strip()
+        shown = subprocess.run(
+            ["git", "show", f"{revision}:templates/manifest.yaml"],
+            cwd=ROOT, capture_output=True, text=True, encoding="utf-8")
+        if shown.returncode != 0:
+            failures.append(f"  the manifest at {revision[:12]} could not be "
+                            f"read: {shown.stderr.strip()}")
+            return seen.failures() + failures, seen.notes()
+        was_text = shown.stdout
+        basis = (f"  baseline: the merge base {revision[:12]} of HEAD and "
+                 f"{ref}")
+    else:
+        was_text = now_text
+        basis = (f"  baseline: {UPSTREAM_REF_ENV} is unset, so this is "
+                 f"upstream and the manifest is compared with itself")
+
+    was, now = yaml.safe_load(was_text), yaml.safe_load(now_text)
+    seen.count("upstream keys compared",
+               [k for k in UPSTREAM_KEYS if k in was])
+    for finding in upstream_key_edits(was, now):
+        failures.append(
+            f"  {finding}: a fork appends under stacks:, platform: and its "
+            f"own keys, and leaves upstream's as it last merged them"
+        )
+
+    return seen.failures() + failures, seen.notes() + [basis]
+
 CHECKS = [
     {"id": "SYS-01", "spec": "SAIT-SMK-SYS-01-001A",
      "title": "DEPENDS ON paths resolve to existing files", "fn": check_sys_01},
@@ -2545,6 +2690,9 @@ def check_sys_19():
     {"id": "SYS-19", "spec": "SAIT-SMK-SYS-19-001A",
      "title": "resolve.py names a missing dependency and a dependency cycle",
      "fn": check_sys_19},
+    {"id": "SYS-20", "spec": "SAIT-SMK-SYS-20-001A",
+     "title": "A fork leaves upstream's manifest keys as it last merged them",
+     "fn": check_sys_20},
 ]
 
 
 
@@ -0,0 +1,85 @@
+---
+id: SAIT-SMK-SYS-20-001A
+title: A fork leaves upstream's manifest keys as it last merged them
+product: sait
+type: smoke
+area: SYS
+priority: p1
+status: ready
+environment: [local, ci]
+automatable: yes
+created: 2026-10-17
+author: Branimir Georgiev
+product-version: "2.x"
+tags: [manifest, fork, composition, merge]
+---
+
+## Short description
+
+> **Given** a fork's manifest and the upstream revision the fork last merged
+> **When** the keys upstream owns — `core`, `base`, `backend`, `frontend` —
+> are compared between the two
+> **Then** any entry added, removed or changed under them fails, naming the
+> key and the entry, because that edit is what turns the fork's next
+> upstream merge into a conflict
+
+## Results
+
+| Result | Condition |
+|--------|-----------|
+| PASSED | Every planted case yields exactly its owed findings, and the real manifest's upstream keys match the baseline |
+| FAILED | A planted case yields findings other than those it owes |
+| FAILED | An upstream key's entry is added, removed or changed against the baseline |
+| FAILED | `SAIT_UPSTREAM_REF` is set and shares no history with HEAD, or the baseline manifest cannot be read |
+| FAILED | No planted case or no upstream key was compared |
+| SKIPPED | — |
+| BLOCKED | — |
+| ERROR | PyYAML is not installed |
+
+## Steps
+
+### Prerequisites
+
+- Repository cloned locally, with git
+- Python 3 and PyYAML
+- In a fork: a ref holding upstream's history, named in `SAIT_UPSTREAM_REF`
+
+### Setup
+
+— (operates on the committed tree and the working manifest)
+
+### Execution
+
+1. Compare each planted fork manifest in `OWNERSHIP_CASES` with the planted
+   upstream manifest, and compare the findings with those the case owes
+2. Take the baseline: with `SAIT_UPSTREAM_REF` set, the manifest at the
+   merge base of HEAD and that ref; unset, the working manifest itself
+3. Compare the working manifest's upstream keys with the baseline's
+4. Report the planted-case count, the upstream keys compared, and the
+   baseline used
+
+### Assertions
+
+1. Assert a planted fork that appends a stack and a platform, and adds a
+   key of its own, yields no finding — the control that legal appends pass
+2. Assert planted edits yield one finding each: the core tier changed, an
+   upstream entry changed, an entry added under an upstream key, and an
+   upstream entry removed
+3. Assert the real manifest's upstream keys match the baseline
+4. Assert both counts are non-zero, per ADR-034
+
+### Negative controls
+
+1. **The defect that motivated the check.** A fork edits an upstream key
+   and nothing notices until its next upstream merge conflicts. Run with
+   `SAIT_UPSTREAM_REF` at a revision before an upstream-key change and the
+   check names that entry
+2. **A comparison that finds nothing.** A comparison that returns no
+   findings passes upstream's run against itself; the planted edits fail
+   against it, each by its owed finding
+
+## Related
+
+- ADR-049 — a fork appends under `stacks:`, `platform:` and its own keys,
+  and never edits upstream's
+- ADR-034 — why the counts are reported and floored