chaincompiler 0.3.0__tar.gz

chaincompiler-0.3.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: chaincompiler
+Version: 0.3.0
+Summary: The printing press for agent cognition chains: learn → gate → compile → prime
+Requires-Python: >=3.11
+Requires-Dist: honeyc==0.3.0
+Requires-Dist: rulecatcher==0.3.0
+Requires-Dist: agent-skilltree>=0.4.0
+Requires-Dist: agent-prompt-engineering>=0.2.0
+Provides-Extra: persona
+Requires-Dist: glyphsteer==0.3.0; extra == "persona"

chaincompiler-0.3.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "chaincompiler"
+version = "0.3.0"
+description = "The printing press for agent cognition chains: learn → gate → compile → prime"
+requires-python = ">=3.11"
+# honeyc + the *CC are vendored in this monorepo (packages/); install.sh wires them.
+# agent-prompt-engineering is the published prompt-engine BASE chaincompiler imports DOWN onto.
+dependencies = ["honeyc==0.3.0", "rulecatcher==0.3.0", "agent-skilltree>=0.4.0", "agent-prompt-engineering>=0.2.0"]
+
+# A lazy import is an optional extra (DESIGN.md §18): the `persona` front end imports glyphsteer inside its functions.
+[project.optional-dependencies]
+persona = ["glyphsteer==0.3.0"]
+
+# NOTE: the `chaincompiler` CLI command moved to the `chainaios` package (its AIOS subcommands are
+# *CC-coupled, which would make this BASE import the *CC). The command NAME is unchanged — see
+# packages/chainaios/pyproject.toml [project.scripts].
+
+[tool.setuptools.packages.find]
+where = ["src"]

chaincompiler-0.3.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

chaincompiler-0.3.0/src/chaincompiler/__init__.py

@@ -0,0 +1,31 @@
+"""chaincompiler — the ChainCompiler BASE: the generic compiler-compiler (DESIGN.md §2).
+
+This package imports only DOWN (APE + honeyc + rulecatcher). It is the machine the *CC are MADE FROM:
+  - forge   : the generic "forge a language" core (Language / forge / gate_language / grammar / package_skill)
+  - bridge  : the HoneyC compile seam + the rulecatcher grammar seam (learn / gate, re-exported from APE)
+  - prime   : build_prime — the re-injectable prime block
+  - skillpack / persona : SKILL.md packaging + the glyph-persona-program compiler
+
+ACCC / CORCC / SCCC build ON this base (they import CC). CC NEVER imports the *CC. The Bandit AIOS
+application that orchestrates AC+CoR+SC (construct_language / GBA / HBA / COG) lives ABOVE the *CC in the
+`chainaios` package — it was extracted out of here precisely so this base no longer imports the *CC.
+"""
+from __future__ import annotations
+
+__version__ = "0.3.0"
+
+from .bridge import compile_chain, gate, learn
+from .prime import build_prime
+from .skillpack import skill_markdown, slugify, write_skill
+# the generic compiler-compiler core — the machine the *CC are MADE FROM (DESIGN.md §2). Imports only APE.
+from .forge import Language, forge, gate_language, grammar, package_skill
+# re-export the APE cognition helper the *CC need, so they route through CC (not around it to APE):
+from prompt_engineering import cor_skeleton
+
+__all__ = [
+    "learn", "gate", "compile_chain", "build_prime",
+    "write_skill", "skill_markdown", "slugify",
+    # the forge core (ACCC/CORCC/SCCC import these DOWN from here):
+    "Language", "forge", "gate_language", "grammar", "package_skill", "cor_skeleton",
+    "__version__",
+]

chaincompiler-0.3.0/src/chaincompiler/bridge.py

@@ -0,0 +1,36 @@
+"""The HoneyC seam (compile a gated chain into lenses) + re-exports of the rulecatcher seam.
+
+The rulecatcher seam — `learn` / `gate` / `grammar_lines` / `foreign_tokens` — MOVED DOWN to
+`prompt_engineering.grammar` (REBUILD-SPEC.md §4 — single source of truth, D1). chaincompiler keeps the
+HoneyC-wrapping `compile_chain` (HoneyC is chaincompiler's concern, §6) and RE-EXPORTS the grammar seam,
+so `from chaincompiler.bridge import learn, gate, grammar_lines` and `from chaincompiler import learn,
+gate` stay byte-stable.
+"""
+from __future__ import annotations
+
+from honeyc.normalize import normalize
+from honeyc.parser import parse_text
+from honeyc.render import render
+
+# the rulecatcher seam now lives in the base (DOWN edge):
+from prompt_engineering.grammar import (
+    ForeignToken,
+    foreign_tokens,
+    gate,
+    grammar_lines,
+    learn,
+)
+
+
+def compile_chain(chain: str) -> dict:
+    """Compile a chain through HoneyC into semantic lenses."""
+    program = parse_text(chain)
+    return {
+        "readable": render(program, "readable"),
+        "triples": render(program, "triples"),
+        "prose": render(program, "prose"),
+        "statements": normalize(program),
+    }
+
+
+__all__ = ["compile_chain", "learn", "gate", "grammar_lines", "foreign_tokens", "ForeignToken"]

chaincompiler-0.3.0/src/chaincompiler/forge.py

@@ -0,0 +1,59 @@
+"""forge.py — the generic compiler-compiler core (the "forge a language" move).
+
+This is the machine the *CC are *made FROM* (DESIGN.md §2: ACCC/CORCC/SCCC import CC). A forged
+language = a rulecatcher SCOPE holding a ratified grammar; `forge` mints one, `gate_language` enforces it,
+`grammar` reads it back, `package_skill` wraps a compiled body as a publishable `<name>/SKILL.md`. Each
+*CC calls these with its own chain-kind prefix + render/parse and adds nothing to the mechanism.
+
+CC imports only DOWN (APE + rulecatcher); it never imports the *CC.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from prompt_engineering import write_skill, grammar_lines, learn
+from prompt_engineering.grammar import gate as _gate
+from rulecatcher.db import connect, list_rules
+
+
+@dataclass
+class Language:
+    """A forged language: a rulecatcher scope holding a ratified grammar."""
+    name: str
+    scope: str
+    db: str
+    rule_count: int
+
+
+def forge(kind: str, name: str, examples: list[str], *, db: str, strict: bool = False) -> Language:
+    """Mint a `kind` language for `name` from example chains (scope = `<kind>:<name>`).
+
+    strict=False → learn the SHAPE only (next_kind): any vocabulary is allowed.
+    strict=True  → also pin the vocabulary (next_token): the gate enforces domain-specific tokens.
+    """
+    scope = f"{kind}:{name}"
+    rule_types = ("next_kind", "next_token") if strict else ("next_kind",)
+    with connect(db) as cx:
+        adopted = learn(cx, examples, scope=scope, rule_types=rule_types, label=f"forge:{name}")
+    return Language(name=name, scope=scope, db=db, rule_count=len(adopted))
+
+
+def gate_language(language: Language, candidate: str) -> tuple[list, list]:
+    """Lint a candidate chain against a forged language's ratified grammar."""
+    with connect(language.db) as cx:
+        return _gate(cx, candidate, scope=language.scope)
+
+
+def grammar(language: Language) -> list[str]:
+    """The ratified grammar lines of a forged language."""
+    with connect(language.db) as cx:
+        return grammar_lines(list_rules(cx, "adopted", scope=language.scope))
+
+
+def package_skill(name: str, body: str, *, out_dir: str, description: str,
+                  extra: dict | None = None):
+    """Wrap a compiled chain body as a publishable `<name>/SKILL.md` package."""
+    return write_skill(name, description, body, out_dir=out_dir, extra=extra)
+
+
+__all__ = ["Language", "forge", "gate_language", "grammar", "package_skill"]

chaincompiler-0.3.0/src/chaincompiler/persona.py

@@ -0,0 +1,157 @@
+"""Persona compiler — the front-end that ingests a glyph-persona-program and emits
+the artifacts the rest of ChainCompiler already eats.
+
+A BizziBee-style prompt is not prose: it is a program in a cognition-DSL with three
+layers, each of which a ChainCompiler tool already compiles —
+
+  [VarDefs]{ [🌸‍💧]=NectarWF, 📃=drilldown, … }  → a glyphsteer LEGEND (glyph↔meaning)
+  🌸‍💧 → 🍯 → 🍹  (dense-rune chains)              → HoneyC compiles / rulecatcher gates
+  ⚙️0–5  (if / while / for / 🔁 / terminal)        → a workflow (the SI executes; here: extracted)
+  [ROLE]…[/ROLE]  (the persona wrapper)            → a SKILL.md (the one type)
+
+So this module parses the human-authored glyph-persona into: a `legend.json`, a list of
+workflow steps, and a `<cogid>/SKILL.md` — putting the persona INSIDE the closed algebra.
+Full execution of the ⚙️ control flow is the SI's job (ASPIRATIONAL: `persona run`).
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .skillpack import slugify, write_skill
+
+# operator glyphs that are NOT vocabulary entries (arrows / connectors)
+_OPERATORS = set("→⇒⇔↔⟶⇄⟷=+/")
+_NONASCII = re.compile(r"[^\x00-\x7f]+")
+_IDENT = re.compile(r"[A-Za-z][A-Za-z0-9]*")
+_HEADER = re.compile(r"^\[([A-Za-z][A-Za-z0-9]*)\]:\s*(.*)$", re.M)
+_VARDEFS = re.compile(r"\[VarDefs\]:\s*\{(.*?)\}\s*(?:\n|$)", re.S)
+_STEP = re.compile(r"⚙️([0-9][0-9.]*)\)\s*`?(.*)")
+_CTRL = re.compile(r"\b(if|while|for|end)\b|🔁", re.I)
+
+
+@dataclass
+class Persona:
+    name: str
+    description: str
+    fields: dict[str, str] = field(default_factory=dict)
+    legend: object = None                 # a glyphsteer.Vocabulary
+    steps: list[dict] = field(default_factory=list)
+
+
+# ---- block parsing ----------------------------------------------------------
+def parse_header(text: str) -> dict[str, str]:
+    """The `[TAG]: value` header fields (ROLE, CogID, LAW, Mission, …)."""
+    return {k: v.strip() for k, v in _HEADER.findall(text)}
+
+
+def vardefs_text(text: str) -> str:
+    m = _VARDEFS.search(text)
+    return m.group(1) if m else ""
+
+
+# ---- VarDefs → legend -------------------------------------------------------
+def _clean_glyph(run: str) -> str:
+    return "".join(ch for ch in run if ch not in _OPERATORS).strip()
+
+
+def extract_legend(text: str):
+    """Parse the VarDefs glyph↔name pairs into a glyphsteer Vocabulary (best-effort)."""
+    from glyphsteer import Axis, Vocabulary, author
+    raw = vardefs_text(text) or text
+    specs, gseen, nseen = [], set(), set()
+    for piece in re.split(r"[,\n]", raw):
+        glyph_runs = [g for g in (_clean_glyph(r) for r in _NONASCII.findall(piece)) if g]
+        names = _IDENT.findall(piece)
+        if not glyph_runs or not names:
+            continue
+        glyph, name = glyph_runs[0], names[0]
+        if glyph in gseen or name in nseen:
+            continue
+        try:
+            Vocabulary([Axis(name, glyph)])          # validates clean glyph + derivable tag
+        except ValueError:
+            continue
+        gseen.add(glyph); nseen.add(name)
+        specs.append({"name": name, "glyph": glyph, "description": piece.strip()})
+    return author(specs)
+
+
+# ---- ⚙️ steps → workflow ----------------------------------------------------
+def extract_workflow(text: str) -> list[dict]:
+    """The numbered ⚙️N) steps, in order, with detected control-flow keywords."""
+    steps = []
+    for num, body in _STEP.findall(text):
+        body = body.strip().rstrip("`").strip()
+        ctrl = sorted({m.group(0).lower() for m in _CTRL.finditer(body)})
+        steps.append({"step": num, "ctrl": ctrl, "body": body[:140]})
+    return steps
+
+
+# ---- compile ----------------------------------------------------------------
+def parse_persona(text: str) -> Persona:
+    h = parse_header(text)
+    name = h.get("CogID") or h.get("ROLE") or "persona"
+    name = re.sub(r"[*]+$", "", name).strip()
+    return Persona(
+        name=name,
+        description=h.get("Mission", f"{name} persona"),
+        fields=h,
+        legend=extract_legend(text),
+        steps=extract_workflow(text),
+    )
+
+
+def _render_body(p: Persona) -> str:
+    from glyphsteer import render_legend
+    h = p.fields
+    out = [f"# {h.get('ROLE', p.name)} — compiled persona", ""]
+    for key in ("LAW", "Mission", "FnMx", "ActsLike", "OutputWrapper"):
+        if h.get(key):
+            out.append(f"- **{key}**: {h[key]}")
+    out += ["", "## Legend (the glyph vocabulary)", "```", render_legend(p.legend), "```", ""]
+    out += ["## Workflow (⚙️ steps)", ""]
+    for s in p.steps:
+        ctrl = f"  _[{', '.join(s['ctrl'])}]_" if s["ctrl"] else ""
+        out.append(f"{s['step']}. {s['body']}{ctrl}")
+    out += ["", "> Terminal output is reached only after a multi-round sequence of the "
+            "looping steps (the ⚙️ workflow is executable via the SI — ASPIRATIONAL)."]
+    return "\n".join(out)
+
+
+def lint_pipeline(p: Persona) -> dict | None:
+    """If the legend + ChainCompiler grammar gate are available, lint a glyph chain
+    drawn from the legend (rulecatcher syntax gate). Returns a verdict or None."""
+    try:
+        from glyphsteer import GlyphGrammar
+    except Exception:
+        return None
+    glyphs = p.legend.glyphs
+    if len(glyphs) < 2:
+        return None
+    code = p.legend.code(glyphs[:3])
+    try:
+        with GlyphGrammar(p.legend, scope=f"persona_{slugify(p.name)}") as gg:
+            lint = gg.lint(code)
+            return {"chain": code, "verdict": lint.verdict}
+    except Exception:
+        return None
+
+
+def compile_persona(text: str, out_dir: str | Path) -> dict:
+    """Compile a glyph-persona-program → `<cogid>/SKILL.md` + `legend.json`."""
+    from glyphsteer import save_legend
+    p = parse_persona(text)
+    skill_path = write_skill(p.name, p.description, _render_body(p), out_dir=out_dir,
+                             extra={"glyphs": p.legend.code(p.legend.glyphs[:1]) or ""})
+    legend_path = skill_path.parent / "legend.json"
+    save_legend(p.legend, legend_path)
+    return {
+        "name": p.name,
+        "skill": str(skill_path),
+        "legend": str(legend_path),
+        "axes": len(p.legend.axes),
+        "steps": len(p.steps),
+        "gate": lint_pipeline(p),
+    }

chaincompiler-0.3.0/src/chaincompiler/prime.py

@@ -0,0 +1,41 @@
+"""Build the re-injectable PRIME block — the output that closes the loop.
+
+A prime is a context block that (a) tells the LLM the ratified grammar of the
+notation so it generates in-shape, and (b) shows a compiled example so it knows
+what the notation MEANS. Re-injecting the prime self-primes the model; every
+chain it then emits is gated by the same grammar (bridge.gate).
+"""
+from __future__ import annotations
+
+from .bridge import compile_chain, grammar_lines
+
+
+def build_prime(scope: str, adopted_rows: list, example_chain: str) -> str:
+    compiled = compile_chain(example_chain)
+    g = grammar_lines(adopted_rows)
+
+    sections = [
+        f'# PRIME — "{scope}" cognition-chain notation',
+        "",
+        "You think in this notation. Write cognition chains in the shape below; "
+        "every chain you emit is gated against the grammar (fix violations before continuing).",
+        "",
+        f"## Ratified grammar ({len(g)} rules, learned from examples)",
+        *(g or ["(none ratified yet)"]),
+        "",
+        "## A compiled chain (what one MEANS)",
+        f"chain:    {example_chain.strip()}",
+        f"readable: {compiled['readable']}",
+        "",
+        "triples:",
+        *(f"  {line}" for line in compiled["triples"].splitlines()),
+    ]
+    if compiled["prose"].strip():
+        sections += ["", "prose:", f"  {compiled['prose']}"]
+    sections += [
+        "",
+        "## Directive",
+        "Emit chains of this form. End a reasoning chain with a bounded |Predict| "
+        "(the kill-criterion). Stay inside the grammar; the gate will reject drift.",
+    ]
+    return "\n".join(sections)

chaincompiler-0.3.0/src/chaincompiler/skillpack.py

@@ -0,0 +1,12 @@
+"""chaincompiler.skillpack — the skill-packager, now living in the BASE.
+
+MOVED DOWN to `prompt_engineering.skillpack` (REBUILD-SPEC.md §7 — single source of truth, D1). This
+module now just re-exports it, so `from chaincompiler.skillpack import write_skill` and
+`from chaincompiler import write_skill, slugify, skill_markdown` stay byte-stable for existing consumers
+(archetype, the *CC tests).
+"""
+from __future__ import annotations
+
+from prompt_engineering.skillpack import slugify, skill_markdown, write_skill
+
+__all__ = ["slugify", "skill_markdown", "write_skill"]

chaincompiler-0.3.0/src/chaincompiler.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: chaincompiler
+Version: 0.3.0
+Summary: The printing press for agent cognition chains: learn → gate → compile → prime
+Requires-Python: >=3.11
+Requires-Dist: honeyc==0.3.0
+Requires-Dist: rulecatcher==0.3.0
+Requires-Dist: agent-skilltree>=0.4.0
+Requires-Dist: agent-prompt-engineering>=0.2.0
+Provides-Extra: persona
+Requires-Dist: glyphsteer==0.3.0; extra == "persona"

chaincompiler-0.3.0/src/chaincompiler.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+pyproject.toml
+src/chaincompiler/__init__.py
+src/chaincompiler/bridge.py
+src/chaincompiler/forge.py
+src/chaincompiler/persona.py
+src/chaincompiler/prime.py
+src/chaincompiler/skillpack.py
+src/chaincompiler.egg-info/PKG-INFO
+src/chaincompiler.egg-info/SOURCES.txt
+src/chaincompiler.egg-info/dependency_links.txt
+src/chaincompiler.egg-info/requires.txt
+src/chaincompiler.egg-info/top_level.txt
+tests/test_chainpress.py
+tests/test_persona.py
+tests/test_strict_gate.py

chaincompiler-0.3.0/src/chaincompiler.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

chaincompiler-0.3.0/src/chaincompiler.egg-info/requires.txt

@@ -0,0 +1,7 @@
+honeyc==0.3.0
+rulecatcher==0.3.0
+agent-skilltree>=0.4.0
+agent-prompt-engineering>=0.2.0
+
+[persona]
+glyphsteer==0.3.0

chaincompiler-0.3.0/src/chaincompiler.egg-info/top_level.txt

@@ -0,0 +1 @@
+chaincompiler

chaincompiler-0.3.0/tests/test_chainpress.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+
+from rulecatcher.db import connect, list_rules
+
+from chaincompiler.bridge import compile_chain, gate, learn
+from chaincompiler.prime import build_prime
+
+SEED = [
+    "[Observe] ⇒ [Frame] ⇒ [Integrate] ⇒ [Authenticate] ⇒ |Predict|",
+    "[Observe] ⇒ [Frame] ⇒ [Cohere] ⇒ [Authenticate] ⇒ |Predict|",
+    "[Observe] ⇒ [Frame] ⇒ [Integrate] ⇒ [Lever] ⇒ |Predict|",
+]
+
+
+def _db(tmp):
+    return str(Path(tmp) / "t.db")
+
+
+def test_learn_ratifies_shape_grammar():
+    with tempfile.TemporaryDirectory() as tmp, connect(_db(tmp)) as cx:
+        adopted = learn(cx, SEED, scope="cor")
+        assert adopted
+        # shape-only: every adopted rule is a kind rule, none pin vocabulary
+        assert all(r["rule_type"] == "next_kind" for r in adopted)
+
+
+def test_gate_passes_new_vocabulary_in_grammar():
+    # a chain with step names never seen in the seed must still pass — it's a
+    # notation (shape), not a fixed vocabulary.
+    with tempfile.TemporaryDirectory() as tmp, connect(_db(tmp)) as cx:
+        learn(cx, SEED, scope="cor")
+        violations, _ = gate(cx, "[Scan] ⇒ [Map] ⇒ [Decide] ⇒ |Predict|", scope="cor")
+        assert violations == []
+
+
+def test_gate_catches_missing_connector():
+    with tempfile.TemporaryDirectory() as tmp, connect(_db(tmp)) as cx:
+        learn(cx, SEED, scope="cor")
+        violations, fixes = gate(cx, "[Observe] [Frame] ⇒ |Predict|", scope="cor")
+        assert violations
+        assert any("⇒" in f.candidate_tokens for f in fixes)
+
+
+def test_compile_chain_yields_produces_and_bounded():
+    c = compile_chain(SEED[0])
+    assert "Observe produces Frame" in c["triples"]
+    assert "Predict bounded true" in c["triples"]
+
+
+def test_prime_contains_grammar_and_compiled_meaning():
+    with tempfile.TemporaryDirectory() as tmp, connect(_db(tmp)) as cx:
+        learn(cx, SEED, scope="cor")
+        adopted = list_rules(cx, "adopted", scope="cor")
+        block = build_prime("cor", adopted, SEED[0])
+    assert "Ratified grammar" in block
+    assert "produces" in block
+    assert "|Predict|" in block
+    assert "Directive" in block
+
+
+def test_loop_grammar_is_stable_under_new_vocabulary():
+    # closing the loop: fold a gated-clean new chain back in and re-learn;
+    # the shape grammar must NOT grow just because new step names appeared.
+    with tempfile.TemporaryDirectory() as tmp, connect(_db(tmp)) as cx:
+        first = learn(cx, SEED, scope="cor")
+        again = learn(cx, ["[Scan] ⇒ [Map] ⇒ [Decide] ⇒ |Predict|"], scope="cor", label="round2")
+        assert len(again) == len(first)

chaincompiler-0.3.0/tests/test_persona.py

@@ -0,0 +1,57 @@
+"""The persona compiler: a glyph-persona-program → legend + workflow + SKILL.md."""
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("glyphsteer")
+
+from chaincompiler.persona import (compile_persona, extract_legend,
+                                   extract_workflow, parse_header, parse_persona)
+
+EXAMPLE = Path(__file__).resolve().parents[1] / "examples" / "bizzibee.txt"
+TEXT = EXAMPLE.read_text(encoding="utf-8")
+
+
+def test_header_parsed():
+    h = parse_header(TEXT)
+    assert h["CogID"] == "BB"
+    assert h["Mission"].startswith("Produce RoyalJelly")
+
+
+def test_legend_extracts_the_dense_runes():
+    V = extract_legend(TEXT)
+    names = {a.name for a in V.axes}
+    assert {"NectarWF", "RoyalJelly", "drilldown"} <= names
+    # the ZWJ rune 🌸‍💧 is captured as ONE glyph
+    nectar = V.by_name("NectarWF").glyph
+    assert "‍" in nectar and nectar.startswith("\U0001F338")
+
+
+def test_workflow_steps_and_control_flow():
+    steps = extract_workflow(TEXT)
+    nums = [s["step"] for s in steps]
+    assert "0" in nums and "5" in nums                 # the bookend steps
+    allctrl = {c for s in steps for c in s["ctrl"]}
+    assert {"if", "while", "for"} <= allctrl           # control flow detected
+    assert any("🔁" in s["ctrl"] for s in steps)        # the loop-back
+
+
+def test_compile_writes_skill_and_legend(tmp_path: Path):
+    res = compile_persona(TEXT, tmp_path)
+    assert res["name"] == "BB"
+    assert res["axes"] >= 4 and res["steps"] >= 6
+    skill = Path(res["skill"])
+    legend = Path(res["legend"])
+    assert skill.exists() and skill.name == "SKILL.md"
+    assert legend.exists()
+    body = skill.read_text(encoding="utf-8")
+    assert "compiled persona" in body and "Legend" in body and "Workflow" in body
+    # the rulecatcher gate ran and the legend chain is well-formed
+    assert res["gate"] is None or res["gate"]["verdict"] in {"ok", "orthogonal", "syntax_break"}
+
+
+def test_roundtrip_legend_is_loadable(tmp_path: Path):
+    from glyphsteer import load_legend
+    res = compile_persona(TEXT, tmp_path)
+    V = load_legend(res["legend"])
+    assert V.by_name("RoyalJelly") is not None

chaincompiler-0.3.0/tests/test_strict_gate.py

@@ -0,0 +1,40 @@
+"""Metaformal self-test (frozen): the STRICT gate rejects foreign tokens at branch points.
+
+A metaformal self-test caught the plain gate ADMITTING a foreign token `❌NOPE❌` (it's positional /
+rule-triggered, and the position after `⇒` is a genuine branch point no confidence rule governs). The
+fix: an opt-in closed-class vocabulary check (`gate(..., strict=True)`). This OBSERVES the fixed gate's
+real verdicts — the substrate is the oracle. See ~/.claude/skills/metaformal-self-test.
+"""
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+
+from rulecatcher.db import connect
+from chaincompiler.bridge import learn, gate
+
+_EXAMPLES = ["[ac:a] ⇒ [cor:b] ⇒ |C|", "[ac:a] ⇒ [ac:b] ⇒ [cor:c] ⇒ |D|"]
+
+
+def _gate(chain: str, *, strict: bool):
+    db = str(Path(tempfile.mkdtemp()) / "g.db")
+    with connect(db) as cx:
+        learn(cx, _EXAMPLES, scope="cog")
+        viol, _ = gate(cx, chain, scope="cog", strict=strict)
+    return viol
+
+
+def test_strict_gate_rejects_foreign_token_at_a_branch_point():
+    # OBSERVE: the foreign token is admitted plain (the gap), rejected strict (the fix)
+    assert len(_gate("[ac:x] ⇒ ❌NOPE❌ ⇒ |Z|", strict=False)) == 0      # the documented gap
+    assert len(_gate("[ac:x] ⇒ ❌NOPE❌ ⇒ |Z|", strict=True)) >= 1       # the fix: REJECT
+
+
+def test_strict_gate_still_admits_a_valid_chain():
+    # the fix must not false-positive a well-formed chain
+    assert len(_gate("[ac:x] ⇒ [cor:y] ⇒ |Z|", strict=True)) == 0
+
+
+def test_strict_gate_still_catches_structural_errors():
+    # missing arrows are caught by the positional rules, strict or not
+    assert len(_gate("[ac:x] [cor:y] |Z|", strict=True)) >= 1