diff --git a/AGENTS.md b/AGENTS.md
index 6ccd081..5fa6956 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -31,6 +31,7 @@ cd simulations/gadm02 && python3 -B agency.py   # GADM-0.4 cohort agency
 cd simulations/gadm02 && python3 -B grounded_readings.py   # readings under grounded parameters
 cd simulations/gadm02 && python3 -B band_probe.py   # scenarios across the adoption band B1–B4
 cd simulations/gadm02 && python3 -B legitimacy.py   # sentiment and legitimacy loop across the band
+cd simulations/gadm02 && python3 -B jurisdictions.py   # jurisdiction archetypes J1–J4 across the band
 ```
 
 Reality checkpoints (ASSEMBLY-WP-0010): scheduled by activity-core and
diff --git a/models/AdoptionBand.md b/models/AdoptionBand.md
index d028df4..8ce6212 100644
--- a/models/AdoptionBand.md
+++ b/models/AdoptionBand.md
@@ -165,3 +165,96 @@ peak (0.40 at year 10).
   `Ppol` suggests that it should.
 - The weights in `pb` and all loop parameters are not yet chosen by data. The
   readings are qualitative until the L6 sentiment series constrain them.
+
+## 4. Jurisdiction archetypes (T04)
+
+### 4.1 Settings
+
+Archetypes are lever settings (`research/ScenarioBandMethod.md` § 4). Every
+archetype starts from the same anchor equilibrium. Its levers apply from
+t = 0, so differences come from policy, not from different starting states.
+`perm` (deployment permissiveness) is a new `gadm04` lever, default 1. It
+scales the organism inflow.
+
+| Archetype | perm | m | expl | L / lin_open | x_att | other | initial Σ |
+|---|---|---|---|---|---|---|---|
+| J1 rights-first / precautionary | 0.6 | 0.7 | 0.7 | 0.6 / 0.6 | 0.3 | std 0.6 | 0.45 |
+| J2 deregulated fast-adopter | 1.5 | 0.2 | 0.2 | 0.2 / 0.2 | 0.7 | — | 0.65 |
+| J3 platform-led | 1.3 | 0.1 | 0.4 | 0.1 / 0.1 | 0.8 | disc 0.6 | 0.5 |
+| J4 state-coordinated | 1.3 | 0.2 | 0.4 | 0.2 / 0.2 | 0.5 | managed sentiment: sig_gain 0.5, leg_lag 10 | 0.6 |
+
+Lever magnitudes are choices that express the method's low/medium/high
+table, not estimates. Reproduce: `cd simulations/gadm02 && python3 -B
+jurisdictions.py` (`results/jurisdictions.md`).
+
+### 4.2 Results
+
+J1 has the highest VFAC at t 100 at every anchor, with and without the
+legitimacy loop. It is the only archetype that keeps domination below the
+P floor (P ≤ 0.65 against 0.79–0.89 for J2–J4).
+
+J1 − J2 (positive = lagging does better):
+
+| Anchor | Loop | Δ mean Y* 0–25 | Δ mean Y* 0–100 | Δ VFAC t 100 | Δ G | Δ A |
+|---|---|---|---|---|---|---|
+| B1 | off / on | +0.000 / +0.012 | +0.195 / +0.205 | +0.32 / +0.29 | +0.24 / +0.21 | +0.14 / +0.06 |
+| B2 | off / on | −0.024 / +0.024 | +0.167 / +0.247 | +0.32 / +0.27 | +0.23 / +0.20 | +0.15 / +0.03 |
+| B3 | off / on | −0.038 / +0.047 | +0.074 / +0.263 | +0.25 / +0.23 | +0.16 / +0.15 | +0.19 / +0.03 |
+| B4 | off / on | −0.044 / +0.069 | −0.017 / +0.271 | +0.18 / +0.19 | +0.13 / +0.12 | +0.17 / +0.02 |
+
+Decomposition (each lever regime at perm 0.6 versus 1.5, rest unchanged):
+lagging by itself always costs early output (mean Y* 0–25 lower by 0.01 to
+0.10) and raises VFAC by 0.01–0.13. Under J2 levers with the legitimacy loop
+on, speed hardly matters (|Δ VFAC| ≤ 0.01), because backlash slows adoption
+anyway.
+
+### 4.3 Readings
+
+1. **The archetype gap comes mainly from rights, not from speed.** The J1–J2
+   VFAC gap is 0.18–0.32. The speed component alone is 0.01–0.13. The
+   owner's question "is lagging better or worse?" therefore splits: lagging
+   *as such* costs output early and helps agency and attention a little. What
+   decides the long run is membrane rights, open lineages and attention
+   protection.
+2. **"Europe lags" (J1-like):** the model says lagging costs early output when
+   there is no backlash (B2–B4, loop off: −0.02 to −0.04 mean Y*). It does
+   not make the EU worse off in the long run at any anchor. This rests on the
+   rights levers and on the closed-economy assumption: a J1 jurisdiction that
+   imports concentrated foreign lineages does not get J1's L and lin_open.
+3. **"Argentina may thrive" (J2-like):** a J2 regime is richer early only
+   without the legitimacy loop and only at B2–B4 (+0.02 to +0.04 mean Y*
+   0–25). With the loop, the positive start turns into backlash (Σ 0.65 →
+   0.21–0.29). J2 then ends poorer than J1 at every anchor and breaks the
+   domination floor. "Thriving" in the model requires sentiment that stays
+   positive, which requires broad claims and contained domination. That is
+   what checkpoint indicators L6 (sentiment) and F2 (concentration) can test.
+4. **Managed sentiment (J4) sustains adoption but not VFAC.** With the loop
+   on, J4 keeps the highest K_Ω (0.38 at B4, t 100 against 0.08 for J2),
+   because its weak and slow sentiment response avoids backlash. Its domination
+   stays at P ≈ 0.82, and VFAC is among the lowest.
+5. **Long-run prosperity follows domination.** Y* falls in J2–J4 because
+   domination lowers effective demand and selected value in GADM. The
+   reading "deregulation is poorer in the long run" depends on that
+   mechanism (GADM-0.2 § auxiliaries) and should be read as conditional on it.
+
+### 4.4 Mapping real jurisdictions (provisional)
+
+Policy evidence as known up to 2025. The L7 legislation collection at each
+checkpoint updates it, and the mapping is revisited at every full checkpoint.
+
+| Jurisdiction | Nearest archetype | Evidence | Open questions |
+|---|---|---|---|
+| EU | J1, with moderate perm | AI Act (Reg. 2024/1689) in force since Aug 2024, prohibitions from Feb 2025, general-purpose AI duties from Aug 2025; DMA; Data Act applicable from Sep 2025. Digital-omnibus proposals (late 2025) to delay parts of the high-risk regime point to drift toward higher perm. | lineage imports: EU adoption runs largely on non-EU lineages, so effective L and lin_open are lower than its rules suggest |
+| US | J3 (market structure) with J2 federal stance | Jan 2025 executive order revoking EO 14110; AI Action Plan (Jul 2025); no federal AI statute. Several state laws (e.g. Colorado, California) apply rights levers locally. | federal–state split: one archetype per level may be needed |
+| Argentina | J2 by stance | Deregulation programme (DNU 70/2023, Ley Bases 2024 with the RIGI investment regime); no comprehensive AI law as of 2025. | adoption level unknown (L3 manual); AR adopts foreign lineages, so its L and lin_open are set abroad; initial sentiment unmeasured (L6) |
+| (reference) China | J4 | state-coordinated deployment, algorithm registration and generative-AI rules | not a tracked jurisdiction; anchors J4 only |
+
+### 4.5 Limitations
+
+- Closed economy: no lineage import, trade or capital flows between
+  jurisdictions. This is the largest gap for both hypotheses.
+- One lever setting per archetype. No lever trajectories (for example the EU
+  loosening over time).
+- The output advantage of fast adoption is short-lived in the model partly
+  by construction (domination feeds back on demand); a model with
+  export-led gains from organisms could reverse reading 3.
diff --git a/simulations/README.md b/simulations/README.md
index dd0e268..d9d523c 100644
--- a/simulations/README.md
+++ b/simulations/README.md
@@ -9,7 +9,7 @@ model version it implements.
 | `gadm02/gadm03.py` | GADM-0.3: power channels, wealth, attention (`models/GADM-0.3.md`) | `power_channels.py`, `wealth.py`, `organism_grid.py`, `test_gadm03.py` |
 | `gadm02/gadm03c.py` | GADM-0.3 with life-cycle cohorts (`models/GADM-0.3.md` § 5) | `life_cycle.py`, `test_gadm03c.py` |
 | `gadm02/gadm04.py` | GADM-0.4: durable capability, grounded dO, equilibrium start, cohort agency (`models/GADM-0.4.md`) | `life_cycle.py --model gadm04`, `robustness.py`, `agency.py`, `grounded_readings.py`, `test_gadm04.py` |
-| `gadm02/grounding.py` | evidence-grounded parameter sets and adoption band B1–B4 (`models/ParameterGrounding.md`, `models/AdoptionBand.md`) | `variant("slow" \| "central" \| "fast" \| "aggressive")`, `band_probe.py`, `legitimacy.py` |
+| `gadm02/grounding.py` | evidence-grounded parameter sets and adoption band B1–B4 (`models/ParameterGrounding.md`, `models/AdoptionBand.md`) | `variant("slow" \| "central" \| "fast" \| "aggressive")`, `band_probe.py`, `legitimacy.py`, `jurisdictions.py` |
 
 Python 3.10+, standard library only. Use `python3 -B` after quick edits: a stale
 bytecode cache can mask same-size changes made within the same second.
diff --git a/simulations/gadm02/gadm04.py b/simulations/gadm02/gadm04.py
index be95bc0..2748ba6 100644
--- a/simulations/gadm02/gadm04.py
+++ b/simulations/gadm02/gadm04.py
@@ -83,6 +83,9 @@ PARAMS.update({
     "leg_m": 0.5,       # membrane rights tightening per unit of stance below neutral
     "leg_expl": 0.5,    # explainability tightening per unit of stance below neutral
     "sig_pb0": None,    # reference perceived benefit; None = value at the initial state
+    # WP-0009-T04: deployment permissiveness of a jurisdiction; scales the organism
+    # inflow (investment, learning, seeding) like the legislative stance. 1 = neutral.
+    "perm": 1.0,
 })
 
 
@@ -151,12 +154,15 @@ def derivatives(s: dict, p: dict) -> tuple[dict, dict]:
         Ko = s["Ko"]
         grow = (p["aO"] * a["Vsel"] * a["dem"] + p["ell"] * Ko * a["dem"] * s["Q"]) * (1 - Ko)
         d["Ko"] += p["selfenh"] * Ko * grow
-    if p["sent"]:
-        # sentiment and permissiveness scale the organism inflow, not its depreciation
-        scale = max(0.0, 1 + p["sig_adopt"] * 2 * (s["Sig"] - 0.5)) \
-            * max(0.0, 1 + p["leg_perm"] * 2 * (s["Lg"] - 0.5))
+    if p["sent"] or p["perm"] != 1.0:
+        # permissiveness, sentiment and stance scale the organism inflow, not its depreciation
+        scale = p["perm"]
+        if p["sent"]:
+            scale *= max(0.0, 1 + p["sig_adopt"] * 2 * (s["Sig"] - 0.5)) \
+                * max(0.0, 1 + p["leg_perm"] * 2 * (s["Lg"] - 0.5))
         inflow = d["Ko"] + p["dO"] * s["Ko"]
         d["Ko"] = scale * inflow - p["dO"] * s["Ko"]
+    if p["sent"]:
         pb = perceived_benefit(s, a, p)
         pb0 = pb if p["sig_pb0"] is None else p["sig_pb0"]
         target = min(1.0, max(0.0, 0.5 + p["sig_gain"] * (pb - pb0)))
diff --git a/simulations/gadm02/jurisdictions.py b/simulations/gadm02/jurisdictions.py
new file mode 100644
index 0000000..342a5ce
--- /dev/null
+++ b/simulations/gadm02/jurisdictions.py
@@ -0,0 +1,120 @@
+"""Jurisdiction archetypes J1-J4 across the adoption band (ASSEMBLY-WP-0009-T04).
+
+Archetypes are lever settings (research/ScenarioBandMethod.md § 4), not
+country names. Every archetype starts from the same anchor equilibrium; its
+levers apply from t = 0. Tests the owner's hypotheses: under which band anchor
+and with or without the legitimacy loop does lagging (J1) or fast deregulated
+adoption (J2) do better?
+
+Usage: python3 -B simulations/gadm02/jurisdictions.py
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.dont_write_bytecode = True
+
+import gadm04 as g  # noqa: E402
+import grounding as gr  # noqa: E402
+
+OUT = Path(__file__).resolve().parent / "results"
+ANCHORS = list(gr.BAND)
+FLOORS = {"G": (">=", 0.2), "E": (">=", 0.2), "P": ("<=", 0.7), "A": (">=", 0.2)}
+
+# (params, initial sentiment). Defaults: m .30, L .30, lin_open .30, expl .40,
+# x_att .50, disc .40, std .50, perm 1.
+ARCHETYPES = {
+    "J1": ("rights-first / precautionary",
+           {"perm": 0.6, "m": 0.7, "expl": 0.7, "L": 0.6, "lin_open": 0.6, "std": 0.6, "x_att": 0.3}, 0.45),
+    "J2": ("deregulated fast-adopter",
+           {"perm": 1.5, "m": 0.2, "expl": 0.2, "L": 0.2, "lin_open": 0.2, "x_att": 0.7}, 0.65),
+    "J3": ("platform-led",
+           {"perm": 1.3, "m": 0.1, "expl": 0.4, "L": 0.1, "lin_open": 0.1, "disc": 0.6, "x_att": 0.8}, 0.5),
+    "J4": ("state-coordinated",
+           {"perm": 1.3, "m": 0.2, "expl": 0.4, "L": 0.2, "lin_open": 0.2, "x_att": 0.5,
+            "sig_gain": 0.5, "leg_lag": 10.0}, 0.6),   # managed sentiment: weak, slow response
+}
+LOOP = {"off": 0.0, "on": 1.0}
+
+
+def run(anchor: str, j: str, loop: str, var: dict, perm: float | None = None) -> dict:
+    vp, vi = var[anchor]
+    _t, lev, sig0 = ARCHETYPES[j]
+    lev = lev if perm is None else {**lev, "perm": perm}
+    rows = g.simulate({**vp, **lev, "sent": LOOP[loop]}, {**vi, "Sig": sig0, "Lg": sig0})
+    f = rows[-1]
+    viol = [k for k, (op, lim) in FLOORS.items() if (f[k] < lim if op == ">=" else f[k] > lim)]
+    return {"Ko10": rows[10]["Ko"], "Ko100": f["Ko"],
+            "Y25": sum(r["Ystar"] for r in rows[:26]) / 26, "Y100": sum(r["Ystar"] for r in rows) / len(rows),
+            "V10": rows[10]["VFAC"], "V100": f["VFAC"], "G": f["G"], "A": f["A"], "P": f["P"],
+            "Sig": f["Sig"], "floors": ",".join(viol) or "none"}
+
+
+def verdict(d: dict) -> str:
+    """J1 − J2 differences → reading for the 'lagging' hypothesis."""
+    good = sum(1 for k in ("V100", "G", "A") if d[k] > 0.005)
+    bad = sum(1 for k in ("V100", "G", "A") if d[k] < -0.005)
+    rich = "J2 richer early" if d["Y25"] < -0.005 else "J1 not poorer early"
+    if good == 3:
+        return f"lagging better on all three; {rich}"
+    if bad == 3:
+        return f"lagging worse on all three; {rich}"
+    return f"mixed ({good} better, {bad} worse); {rich}"
+
+
+def main() -> None:
+    OUT.mkdir(exist_ok=True)
+    var = {a: gr.variant(gr.BAND[a]) for a in ANCHORS}
+    res = {(a, j, lp): run(a, j, lp, var) for a in ANCHORS for j in ARCHETYPES for lp in LOOP}
+    lines = [f"# {g.MODEL_VERSION}: jurisdiction archetypes across the band", "",
+             "Generated by `simulations/gadm02/jurisdictions.py` (ASSEMBLY-WP-0009-T04).",
+             "Baseline scenario; archetype levers from t = 0 at each anchor's equilibrium.",
+             "Y̅ 0–25 / 0–100 = mean potential output Y* over the period (prosperity proxy).", "",
+             "## Archetype levers", "", "| Archetype | Levers | Initial Σ |", "|---|---|---|"]
+    for j, (t, lev, s0) in ARCHETYPES.items():
+        lines.append(f"| {j} {t} | " + ", ".join(f"{k} {v}" for k, v in lev.items()) + f" | {s0} |")
+    for lp in LOOP:
+        lines += ["", f"## Legitimacy loop {lp}", "",
+                  "| Anchor | Arch. | K_Ω t10 / t100 | Y̅ 0–25 / 0–100 | VFAC t10 / t100 | G | A | P | Σ end | floors broken |",
+                  "|---|---|---|---|---|---|---|---|---|---|"]
+        for a in ANCHORS:
+            for j in ARCHETYPES:
+                r = res[(a, j, lp)]
+                lines.append(f"| {a} | {j} | {r['Ko10']:.2f} / {r['Ko100']:.2f} | {r['Y25']:.3f} / {r['Y100']:.3f}"
+                             f" | {r['V10']:.3f} / {r['V100']:.3f} | {r['G']:.2f} | {r['A']:.2f} | {r['P']:.2f}"
+                             f" | {r['Sig']:.2f} | {r['floors']} |")
+    lines += ["", "## Hypothesis test: J1 (lagging) − J2 (deregulated fast-adopter)", "",
+              "| Anchor | Loop | Δ Y̅ 0–25 | Δ Y̅ 0–100 | Δ VFAC t100 | Δ G | Δ A | Δ P | reading |",
+              "|---|---|---|---|---|---|---|---|---|"]
+    for a in ANCHORS:
+        for lp in LOOP:
+            r1, r2 = res[(a, "J1", lp)], res[(a, "J2", lp)]
+            d = {k: r1[k] - r2[k] for k in ("Y25", "Y100", "V100", "G", "A", "P")}
+            lines.append(f"| {a} | {lp} | {d['Y25']:+.3f} | {d['Y100']:+.3f} | {d['V100']:+.3f} | {d['G']:+.3f}"
+                         f" | {d['A']:+.3f} | {d['P']:+.3f} | {verdict(d)} |")
+    lines += ["", "## Decomposition: speed (perm) vs. rights levers", "",
+              "Each lever regime run at slow (perm 0.6) and fast (perm 1.5) permissiveness, other levers",
+              "and initial Σ as in the archetype. Δ = slow − fast: the effect of lagging alone.", "",
+              "| Anchor | Loop | Regime | Δ Y̅ 0–25 | Δ Y̅ 0–100 | Δ VFAC t100 | Δ G | Δ A | Δ P |",
+              "|---|---|---|---|---|---|---|---|---|"]
+    for a in ANCHORS:
+        for lp in LOOP:
+            for j in ("J1", "J2"):
+                slow = run(a, j, lp, var, perm=0.6)
+                fast = run(a, j, lp, var, perm=1.5)
+                d = {k: slow[k] - fast[k] for k in ("Y25", "Y100", "V100", "G", "A", "P")}
+                lines.append(f"| {a} | {lp} | {j} levers | {d['Y25']:+.3f} | {d['Y100']:+.3f} | {d['V100']:+.3f}"
+                             f" | {d['G']:+.3f} | {d['A']:+.3f} | {d['P']:+.3f} |")
+    lines += ["", "## Best archetype by VFAC t100", "", "| Anchor | loop off | loop on |", "|---|---|---|"]
+    for a in ANCHORS:
+        best = {lp: max(ARCHETYPES, key=lambda j: res[(a, j, lp)]["V100"]) for lp in LOOP}
+        lines.append(f"| {a} | {best['off']} | {best['on']} |")
+    lines.append("")
+    (OUT / "jurisdictions.md").write_text("\n".join(lines))
+    print("\n".join(lines))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/simulations/gadm02/results/jurisdictions.md b/simulations/gadm02/results/jurisdictions.md
new file mode 100644
index 0000000..d86a73c
--- /dev/null
+++ b/simulations/gadm02/results/jurisdictions.md
@@ -0,0 +1,102 @@
+# GADM-0.4: jurisdiction archetypes across the band
+
+Generated by `simulations/gadm02/jurisdictions.py` (ASSEMBLY-WP-0009-T04).
+Baseline scenario; archetype levers from t = 0 at each anchor's equilibrium.
+Y̅ 0–25 / 0–100 = mean potential output Y* over the period (prosperity proxy).
+
+## Archetype levers
+
+| Archetype | Levers | Initial Σ |
+|---|---|---|
+| J1 rights-first / precautionary | perm 0.6, m 0.7, expl 0.7, L 0.6, lin_open 0.6, std 0.6, x_att 0.3 | 0.45 |
+| J2 deregulated fast-adopter | perm 1.5, m 0.2, expl 0.2, L 0.2, lin_open 0.2, x_att 0.7 | 0.65 |
+| J3 platform-led | perm 1.3, m 0.1, expl 0.4, L 0.1, lin_open 0.1, disc 0.6, x_att 0.8 | 0.5 |
+| J4 state-coordinated | perm 1.3, m 0.2, expl 0.4, L 0.2, lin_open 0.2, x_att 0.5, sig_gain 0.5, leg_lag 10.0 | 0.6 |
+
+## Legitimacy loop off
+
+| Anchor | Arch. | K_Ω t10 / t100 | Y̅ 0–25 / 0–100 | VFAC t10 / t100 | G | A | P | Σ end | floors broken |
+|---|---|---|---|---|---|---|---|---|---|
+| B1 | J1 | 0.07 / 0.12 | 0.423 / 0.516 | 0.551 / 0.642 | 0.65 | 0.55 | 0.13 | 0.45 | none |
+| B1 | J2 | 0.15 / 0.08 | 0.422 / 0.322 | 0.504 / 0.318 | 0.42 | 0.41 | 0.81 | 0.65 | P |
+| B1 | J3 | 0.13 / 0.06 | 0.403 / 0.279 | 0.493 / 0.296 | 0.41 | 0.39 | 0.85 | 0.50 | P |
+| B1 | J4 | 0.14 / 0.07 | 0.424 / 0.338 | 0.519 / 0.331 | 0.42 | 0.49 | 0.81 | 0.60 | P |
+| B2 | J1 | 0.17 / 0.28 | 0.454 / 0.533 | 0.544 / 0.609 | 0.62 | 0.46 | 0.17 | 0.45 | none |
+| B2 | J2 | 0.38 / 0.23 | 0.478 / 0.366 | 0.466 / 0.286 | 0.39 | 0.31 | 0.83 | 0.65 | P |
+| B2 | J3 | 0.32 / 0.19 | 0.456 / 0.332 | 0.458 / 0.272 | 0.39 | 0.31 | 0.86 | 0.50 | P |
+| B2 | J4 | 0.34 / 0.21 | 0.476 / 0.366 | 0.489 / 0.303 | 0.40 | 0.39 | 0.83 | 0.60 | P |
+| B3 | J1 | 0.34 / 0.38 | 0.504 / 0.546 | 0.533 / 0.508 | 0.53 | 0.42 | 0.44 | 0.45 | none |
+| B3 | J2 | 0.60 / 0.44 | 0.542 / 0.472 | 0.422 / 0.254 | 0.36 | 0.23 | 0.85 | 0.65 | P |
+| B3 | J3 | 0.56 / 0.41 | 0.525 / 0.448 | 0.415 / 0.243 | 0.35 | 0.22 | 0.88 | 0.50 | P |
+| B3 | J4 | 0.58 / 0.42 | 0.540 / 0.470 | 0.450 / 0.273 | 0.37 | 0.30 | 0.84 | 0.60 | P |
+| B4 | J1 | 0.66 / 0.61 | 0.585 / 0.599 | 0.517 / 0.402 | 0.46 | 0.34 | 0.65 | 0.45 | none |
+| B4 | J2 | 0.84 / 0.72 | 0.629 / 0.616 | 0.379 / 0.222 | 0.33 | 0.17 | 0.87 | 0.65 | P,A |
+| B4 | J3 | 0.83 / 0.71 | 0.621 / 0.610 | 0.368 / 0.211 | 0.31 | 0.15 | 0.89 | 0.50 | P,A |
+| B4 | J4 | 0.84 / 0.73 | 0.628 / 0.621 | 0.407 / 0.240 | 0.33 | 0.22 | 0.86 | 0.60 | P |
+
+## Legitimacy loop on
+
+| Anchor | Arch. | K_Ω t10 / t100 | Y̅ 0–25 / 0–100 | VFAC t10 / t100 | G | A | P | Σ end | floors broken |
+|---|---|---|---|---|---|---|---|---|---|
+| B1 | J1 | 0.06 / 0.17 | 0.424 / 0.519 | 0.551 / 0.631 | 0.64 | 0.52 | 0.14 | 0.60 | none |
+| B1 | J2 | 0.16 / 0.02 | 0.412 / 0.314 | 0.497 / 0.343 | 0.43 | 0.46 | 0.79 | 0.29 | P |
+| B1 | J3 | 0.11 / 0.02 | 0.393 / 0.274 | 0.495 / 0.316 | 0.42 | 0.44 | 0.83 | 0.26 | P |
+| B1 | J4 | 0.16 / 0.05 | 0.425 / 0.323 | 0.513 / 0.337 | 0.42 | 0.50 | 0.80 | 0.44 | P |
+| B2 | J1 | 0.15 / 0.28 | 0.450 / 0.533 | 0.546 / 0.607 | 0.62 | 0.46 | 0.18 | 0.51 | none |
+| B2 | J2 | 0.26 / 0.05 | 0.426 / 0.286 | 0.463 / 0.334 | 0.43 | 0.43 | 0.79 | 0.25 | P |
+| B2 | J3 | 0.20 / 0.03 | 0.408 / 0.257 | 0.470 / 0.312 | 0.42 | 0.42 | 0.83 | 0.24 | P |
+| B2 | J4 | 0.37 / 0.13 | 0.467 / 0.326 | 0.477 / 0.320 | 0.41 | 0.44 | 0.81 | 0.41 | P |
+| B3 | J1 | 0.28 / 0.32 | 0.483 / 0.547 | 0.537 / 0.556 | 0.57 | 0.44 | 0.36 | 0.40 | none |
+| B3 | J2 | 0.32 / 0.08 | 0.436 / 0.284 | 0.434 / 0.328 | 0.42 | 0.41 | 0.80 | 0.22 | P |
+| B3 | J3 | 0.26 / 0.05 | 0.416 / 0.256 | 0.446 / 0.308 | 0.41 | 0.40 | 0.83 | 0.21 | P |
+| B3 | J4 | 0.55 / 0.25 | 0.512 / 0.380 | 0.439 / 0.303 | 0.40 | 0.37 | 0.82 | 0.38 | P |
+| B4 | J1 | 0.48 / 0.35 | 0.523 / 0.546 | 0.527 / 0.520 | 0.54 | 0.43 | 0.42 | 0.34 | none |
+| B4 | J2 | 0.49 / 0.08 | 0.454 / 0.275 | 0.394 / 0.327 | 0.42 | 0.41 | 0.80 | 0.21 | P |
+| B4 | J3 | 0.39 / 0.06 | 0.427 / 0.248 | 0.412 / 0.308 | 0.41 | 0.40 | 0.83 | 0.20 | P |
+| B4 | J4 | 0.76 / 0.38 | 0.576 / 0.453 | 0.400 / 0.287 | 0.38 | 0.32 | 0.83 | 0.34 | P |
+
+## Hypothesis test: J1 (lagging) − J2 (deregulated fast-adopter)
+
+| Anchor | Loop | Δ Y̅ 0–25 | Δ Y̅ 0–100 | Δ VFAC t100 | Δ G | Δ A | Δ P | reading |
+|---|---|---|---|---|---|---|---|---|
+| B1 | off | +0.000 | +0.195 | +0.324 | +0.237 | +0.139 | -0.685 | lagging better on all three; J1 not poorer early |
+| B1 | on | +0.012 | +0.205 | +0.288 | +0.211 | +0.063 | -0.647 | lagging better on all three; J1 not poorer early |
+| B2 | off | -0.024 | +0.167 | +0.322 | +0.232 | +0.151 | -0.659 | lagging better on all three; J2 richer early |
+| B2 | on | +0.024 | +0.247 | +0.273 | +0.197 | +0.027 | -0.617 | lagging better on all three; J1 not poorer early |
+| B3 | off | -0.038 | +0.074 | +0.253 | +0.163 | +0.187 | -0.417 | lagging better on all three; J2 richer early |
+| B3 | on | +0.047 | +0.263 | +0.228 | +0.148 | +0.026 | -0.437 | lagging better on all three; J1 not poorer early |
+| B4 | off | -0.044 | -0.017 | +0.180 | +0.131 | +0.171 | -0.222 | lagging better on all three; J2 richer early |
+| B4 | on | +0.069 | +0.271 | +0.193 | +0.118 | +0.022 | -0.378 | lagging better on all three; J1 not poorer early |
+
+## Decomposition: speed (perm) vs. rights levers
+
+Each lever regime run at slow (perm 0.6) and fast (perm 1.5) permissiveness, other levers
+and initial Σ as in the archetype. Δ = slow − fast: the effect of lagging alone.
+
+| Anchor | Loop | Regime | Δ Y̅ 0–25 | Δ Y̅ 0–100 | Δ VFAC t100 | Δ G | Δ A | Δ P |
+|---|---|---|---|---|---|---|---|---|
+| B1 | off | J1 levers | -0.031 | -0.017 | +0.033 | +0.029 | +0.083 | -0.045 |
+| B1 | off | J2 levers | -0.022 | +0.072 | +0.059 | +0.030 | +0.036 | -0.059 |
+| B1 | on | J1 levers | -0.026 | -0.014 | +0.023 | +0.019 | +0.058 | -0.034 |
+| B1 | on | J2 levers | -0.012 | +0.074 | +0.044 | +0.020 | +0.005 | -0.047 |
+| B2 | off | J1 levers | -0.071 | -0.016 | +0.132 | +0.120 | +0.062 | -0.327 |
+| B2 | off | J2 levers | -0.055 | -0.044 | +0.032 | +0.024 | +0.095 | -0.019 |
+| B2 | on | J1 levers | -0.045 | -0.013 | +0.068 | +0.070 | +0.016 | -0.207 |
+| B2 | on | J2 levers | -0.014 | +0.028 | +0.009 | +0.005 | +0.022 | -0.004 |
+| B3 | off | J1 levers | -0.087 | -0.050 | +0.104 | +0.066 | +0.077 | -0.212 |
+| B3 | off | J2 levers | -0.082 | -0.128 | +0.042 | +0.037 | +0.109 | -0.024 |
+| B3 | on | J1 levers | -0.053 | -0.002 | +0.046 | +0.037 | +0.022 | -0.079 |
+| B3 | on | J2 levers | -0.013 | +0.005 | +0.008 | +0.004 | +0.030 | -0.003 |
+| B4 | off | J1 levers | -0.074 | -0.080 | +0.038 | +0.019 | +0.061 | -0.058 |
+| B4 | off | J2 levers | -0.100 | -0.210 | +0.054 | +0.055 | +0.117 | -0.031 |
+| B4 | on | J1 levers | -0.064 | -0.022 | +0.042 | +0.023 | +0.046 | -0.087 |
+| B4 | on | J2 levers | -0.026 | -0.001 | +0.008 | +0.005 | +0.032 | -0.003 |
+
+## Best archetype by VFAC t100
+
+| Anchor | loop off | loop on |
+|---|---|---|
+| B1 | J1 | J1 |
+| B2 | J1 | J1 |
+| B3 | J1 | J1 |
+| B4 | J1 | J1 |
diff --git a/simulations/gadm02/test_gadm04.py b/simulations/gadm02/test_gadm04.py
index 3a488da..6780b3d 100644
--- a/simulations/gadm02/test_gadm04.py
+++ b/simulations/gadm02/test_gadm04.py
@@ -92,6 +92,12 @@ class TestGrounding(unittest.TestCase):
         on = max(r["Ko"] for r in g.simulate({**p, "sent": 1.0}, i, T=30))
         self.assertLess(on, off)
 
+    def test_permissiveness_scales_adoption(self):
+        self.assertEqual(g.PARAMS["perm"], 1.0)
+        ko = [g.simulate({"perm": v}, T=10)[-1]["Ko"] for v in (0.6, 1.0, 1.5)]
+        self.assertEqual(ko, sorted(ko))
+        self.assertLess(ko[0], ko[1])
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/workplans/ASSEMBLY-WP-0009-adoption-band-jurisdictions.md b/workplans/ASSEMBLY-WP-0009-adoption-band-jurisdictions.md
index 0622ee5..7fd0836 100644
--- a/workplans/ASSEMBLY-WP-0009-adoption-band-jurisdictions.md
+++ b/workplans/ASSEMBLY-WP-0009-adoption-band-jurisdictions.md
@@ -70,7 +70,7 @@ run, and sentiment ends negative everywhere.
 
 ```task
 id: ASSEMBLY-WP-0009-T04
-status: todo
+status: done
 priority: medium
 state_hub_task_id: "863d6962-597f-5303-8e9b-675dfc8da5c3"
 ```
@@ -81,6 +81,13 @@ example the EU AI Act, deregulation programmes). Test the owner's hypotheses:
 under which band anchors and sentiment dynamics does lagging (J1) or
 fast deregulated adoption (J2) do better or worse?
 
+**Done 2026-10-13:** `gadm04` `perm` lever, `jurisdictions.py`,
+`models/AdoptionBand.md` § 4 with a provisional mapping of EU, US, AR. J1 is
+best on VFAC at every anchor. The gap comes mainly from the rights levers;
+lagging by itself costs early output. J2's early lead needs sentiment that
+stays positive. The open-economy gap (lineage import) is now the main
+structural limitation for both hypotheses.
+
 ## Global sensitivity per band anchor
 
 ```task