@@ -0,0 +1,16 @@
+{
+ "schema": "own.net/re-oracle/v1",
+ "label": "Stage 7 gate twin: the same rows as SUGGESTED (shadow)",
+ "entries": [
+  {
+   "callable": "createKey",
+   "effect": "return_fresh_owned",
+   "provenance": "SUGGESTED"
+  },
+  {
+   "callable": "Key.destroy",
+   "effect": "receiver_terminal_release",
+   "provenance": "SUGGESTED"
+  }
+ ]
+}
@@ -0,0 +1,16 @@
+{
+ "schema": "own.net/re-oracle/v1",
+ "label": "Stage 7 seam key for the OwnTS twins (MODELLED)",
+ "entries": [
+  {
+   "callable": "createKey",
+   "effect": "return_fresh_owned",
+   "provenance": "MODELLED"
+  },
+  {
+   "callable": "Key.destroy",
+   "effect": "receiver_terminal_release",
+   "provenance": "MODELLED"
+  }
+ ]
+}
@@ -0,0 +1,13 @@
+// resource-effects Stage 7 seam twin (pre-registered in Own.NET-paperwork stage7-seam-prereg-v1.json):
+// Key is NOT a resource type by the T7 rules (no close()/dispose()); only the effect model makes
+// createKey an acquire and destroy() a release. Truth: k is never destroyed (a leak).
+interface Key {
+  destroy(): void;
+  export(): string;
+}
+declare function createKey(): Key;
+
+export function bug(): void {
+  const k = createKey();
+  k.export();
+}
@@ -0,0 +1,11 @@
+// resource-effects Stage 7 seam twin: the same shape, destroyed. Truth: no leak.
+interface Key {
+  destroy(): void;
+  export(): string;
+}
+declare function createKey(): Key;
+
+export function safe(): void {
+  const k = createKey();
+  k.destroy();
+}
@@ -0,0 +1,22 @@
+# resource-effects Stage 7 — the effect model as a cross-frontend seam (EXPLORATORY)
+
+Research branch `research/resource-effects-v1`. Pre-registered in Own.NET-paperwork
+`paper-eval/resource-effects/stage7-seam-prereg-v1.json`; evidence in `stage7-seam-v1.json`. A seam
+proof for one shape; never TypeScript support. #304 frozen and unchanged; #382 untouched.
+
+The OwnTS twin emitter (`frontend/ownts/ownts_p037x.py`, +49/-4 lines) reads the SAME key file the C#
+extractor reads (`--effects <key.json>`): an ambient factory listed `return_fresh_owned` mints an
+`acquire` even when its declared type carries no `close()`/`dispose()`, and `x.m()` where `<Type>.m` is
+listed `receiver_terminal_release` on a tracked handle is a `release`; the same provenance rule applies
+(DECLARED / BODY_PROVED / MODELLED applied, MINED / SUGGESTED shadow, `--trust-all` = the M6 twin).
+The ops are the ordinary acquire/release; the core (Rust and Python) has 0 changed lines.
+
+Measured on the two twins (`corpus/re-controls/ownts/e7-effects-*.ts`; `tests/test_re_ownts_seam.py`
+pins the 8 rows): without effects both are silent (untracked); with the MODELLED key the bug twin reports
+OWN001 and the safe twin nothing; with the same rows as SUGGESTED both are silent and the emitter counts
+two shadow rows; with `--trust-all` the SUGGESTED rows act. Python == Rust on every row; the eight
+P-037-X twins still pass.
+
+What this shows: the effect vocabulary of this track (two effects), its carrier (the key file) and its
+trust policy (the provenance gate) live outside any language; a frontend contributes only an identity
+matcher (~40 lines here). What it does not show: anything about TypeScript beyond these two twins.
@@ -32,6 +32,7 @@
 _IF = re.compile(r"^\s*if\s*\((.*)\)\s*\{\s*$")
 _RET = re.compile(r"^\s*return\b(.*);\s*$")
 _ELSE = re.compile(r"^\s*\}?\s*else\s*\{\s*$")
+_EFFECT_CALL = re.compile(r"^\s*(\w+)\s*\.\s*(\w+)\s*\(\s*\)\s*;\s*$")
 
 
 def _line_of(text: str, pos: int) -> int:
@@ -75,12 +76,41 @@ def _block_end(lines: list[str], start: int) -> int:
     return len(lines) - 1
 
 
+# resource-effects Stage 7 (research/resource-effects-v1, EXPLORATORY; pre-registered in
+# Own.NET-paperwork paper-eval/resource-effects/stage7-seam-prereg-v1.json): the EFFECT MODEL seam.
+# `--effects <key.json>` reads the same key file the C# extractor reads (entries {callable, effect,
+# provenance}); only DECLARED / BODY_PROVED / MODELLED entries apply, MINED / SUGGESTED are shadow
+# (counted, never applied) unless `--trust-all` (the M6 twin). The ops emitted are the ordinary
+# `acquire` / `release`; the core is untouched. A seam proof for one shape, never TypeScript
+# support.
+_APPLIED = {"DECLARED", "BODY_PROVED", "MODELLED"}
+
+
+def _load_effects(path: str | None, trust_all: bool) -> tuple[dict[str, str], dict[str, int]]:
+    applied: dict[str, str] = {}
+    shadow: dict[str, int] = {}
+    if not path:
+        return applied, shadow
+    with open(path, encoding="utf-8") as fh:
+        doc = json.load(fh)
+    for e in doc.get("entries", []):
+        prov = e.get("provenance", "MODELLED")
+        if prov in _APPLIED or trust_all:
+            applied[e["callable"]] = e["effect"]
+        else:
+            shadow[prov] = shadow.get(prov, 0) + 1
+    return applied, shadow
+
+
 class Emitter:
-    def __init__(self, text: str, module: str, file: str, ordinals: bool) -> None:
+    def __init__(self, text: str, module: str, file: str, ordinals: bool,
+                 effects: dict[str, str] | None = None) -> None:
         self.text = text
         self.module = module
         self.file = file
         self.ordinals = ordinals
+        self.effects = effects or {}
+        self.minted: dict[str, set[str]] = {}
         self.resource_types = {m.group(1) for m in _IFACE.finditer(text)
                                if re.search(r"\b(close|dispose)\s*\(\s*\)\s*:\s*void", m.group(2))}
         self.ambient = {m.group(1): m.group(3) for m in _AMBIENT.finditer(text)}
@@ -91,6 +121,15 @@ def __init__(self, text: str, module: str, file: str, ordinals: bool) -> None:
                                 "start": m.end(), "line": _line_of(text, m.start())}
 
     # --- one function -----------------------------------------------------------------------
+    def _handle_types(self, var: str, fn: dict) -> set[str]:
+        """The declared type(s) a tracked handle may have: the ambient factory's return type that
+        minted it (recorded at the acquire), or the parameter's type."""
+        types = set(self.minted.get(var, ()))
+        for n, ty in fn["params"]:
+            if n == var:
+                types.add(ty)
+        return types
+
     def _sig(self, name: str) -> str:
         return ",".join(ty for _, ty in self.funcs[name]["params"])
 
@@ -153,8 +192,10 @@ def _lower(self, lines: list[str], base_line: int, fn: dict, tracked: set[str],
                 continue
             m = _ACQ_STMT.match(ln)
             if (m and m.group(2) in self.ambient
-                    and self.ambient[m.group(2)] in self.resource_types):
+                    and (self.ambient[m.group(2)] in self.resource_types
+                         or self.effects.get(m.group(2)) == "return_fresh_owned")):
                 tracked.add(m.group(1))
+                self.minted.setdefault(m.group(1), set()).add(self.ambient[m.group(2)])
                 nodes.append({"op": "acquire", "var": m.group(1), "line": line_no,
                               "column": ln.index(m.group(1)) + 1, "kind": "disposable"})
                 i += 1
@@ -164,6 +205,13 @@ def _lower(self, lines: list[str], base_line: int, fn: dict, tracked: set[str],
                 nodes.append({"op": "release", "var": m.group(1), "line": line_no})
                 i += 1
                 continue
+            m = _EFFECT_CALL.match(ln)
+            if (m and m.group(1) in tracked and self.effects
+                    and any(self.effects.get(f"{ty}.{m.group(2)}") == "receiver_terminal_release"
+                            for ty in self._handle_types(m.group(1), fn))):
+                nodes.append({"op": "release", "var": m.group(1), "line": line_no})
+                i += 1
+                continue
             m = _CALL_STMT.match(ln)
             if m and m.group(1) in self.funcs:
                 callee = self.funcs[m.group(1)]
@@ -251,14 +299,23 @@ def main(argv: list[str]) -> int:
     out = argv[argv.index("-o") + 1] if "-o" in argv else None
     if out in args:
         args.remove(out)
+    effects_path = argv[argv.index("--effects") + 1] if "--effects" in argv else None
+    if effects_path in args:
+        args.remove(effects_path)
     if not args:
-        print("usage: ownts_p037x.py FILE.ts [-o facts.json] [--no-ordinal]", file=sys.stderr)
+        print("usage: ownts_p037x.py FILE.ts [-o facts.json] [--no-ordinal] "
+              "[--effects key.json] [--trust-all]", file=sys.stderr)
         return 2
+    effects, shadow = _load_effects(effects_path, "--trust-all" in argv)
+    if shadow:
+        print("re-effects shadow: " + " ".join(f"{k}={v}" for k, v in sorted(shadow.items())),
+              file=sys.stderr)
     path = args[0]
     text = open(path, encoding="utf-8").read()
     stripped = re.sub(r"//[^\n]*", "", text)
     module = re.sub(r"\.[jt]sx?$", "", path.rsplit("/", 1)[-1]).replace("-", "_")
-    facts = Emitter(stripped, module, path, ordinals="--no-ordinal" not in argv).facts()
+    facts = Emitter(stripped, module, path, ordinals="--no-ordinal" not in argv,
+                    effects=effects).facts()
     payload = json.dumps(facts, indent=2)
     if out:
         open(out, "w", encoding="utf-8").write(payload + "\n")
 
@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""resource-effects Stage 7 (research/resource-effects-v1, EXPLORATORY): the effect-model seam on the
+OwnTS twin emitter. corpus/re-controls/ownts/e7-*.ts are the twins frozen in Own.NET-paperwork
+`paper-eval/resource-effects/stage7-seam-prereg-v1.json`; each is emitted under four arms (no effects,
+the MODELLED key, the same rows as SUGGESTED, SUGGESTED with --trust-all) and run through the Python
+reference and, when `OWEN_RUST_CORE` names an own-cli, through Rust (parity). The table is the RECORD
+of the Stage 7 measurement; a row that moves is a change to classify, never one to repair here.
+A seam proof for one shape, never TypeScript support. Always runs (no external toolchain)."""
+
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+import sys
+import tempfile
+
+_REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+_EMIT = os.path.join(_REPO, "frontend", "ownts", "ownts_p037x.py")
+_TWINS = os.path.join(_REPO, "corpus", "re-controls", "ownts")
+_KEYS = os.path.join(_REPO, "corpus", "re-controls", "keys")
+_CODE = re.compile(r"\[(OWN\d{3})\]")
+
+# arm -> emitter options
+_ARMS: dict[str, list[str]] = {
+    "none": [],
+    "model": ["--effects", os.path.join(_KEYS, "effects-ts.json")],
+    "suggested": ["--effects", os.path.join(_KEYS, "effects-ts-suggested.json")],
+    "trustall": ["--effects", os.path.join(_KEYS, "effects-ts-suggested.json"), "--trust-all"],
+}
+# twin -> arm -> codes
+_RECORD: dict[str, dict[str, list[str]]] = {
+    "e7-effects-bug": {"none": [], "model": ["OWN001"], "suggested": [], "trustall": ["OWN001"]},
+    "e7-effects-safe": {"none": [], "model": [], "suggested": [], "trustall": []},
+}
+
+
+def _run(argv: list[str], env: dict[str, str]) -> str:
+    p = subprocess.run(argv, cwd=_REPO, capture_output=True, text=True, env=env)
+    return p.stdout + p.stderr
+
+
+def run() -> int:
+    env = {**os.environ, "PYTHONPATH": _REPO}
+    rust = os.environ.get("OWEN_RUST_CORE")
+    if rust and not os.path.isfile(rust):
+        rust = None
+    fails: list[str] = []
+    with tempfile.TemporaryDirectory() as tmp:
+        for twin, arms in sorted(_RECORD.items()):
+            for arm, want in arms.items():
+                facts = os.path.join(tmp, f"{twin}.{arm}.json")
+                subprocess.run([sys.executable, _EMIT, os.path.join(_TWINS, f"{twin}.ts"),
+                                "-o", facts, *_ARMS[arm]], cwd=_REPO, check=True,
+                               capture_output=True, text=True)
+                py = sorted(_CODE.findall(_run([sys.executable, "-m", "ownlang", "ownir", facts,
+                                                 "--severity", "warning"], env)))
+                if py != sorted(want):
+                    fails.append(f"{twin} [{arm}]: python {py} != recorded {want}")
+                if rust:
+                    rs = sorted(_CODE.findall(_run([rust, "ownir", facts, "--severity", "warning"],
+                                                   {**env, "OWEN_P037X_GUARDED": "0"})))
+                    if rs != py:
+                        fails.append(f"{twin} [{arm}]: rust {rs} != python {py} (parity)")
+    for f in fails:
+        print(f"FAIL: {f}")
+    n = sum(len(a) for a in _RECORD.values())
+    print(f"re ownts seam: {n} row(s), {len(fails)} failed"
+          + ("" if rust else " (Rust parity not checked: OWEN_RUST_CORE unset)"))
+    return 1 if fails else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(run())