chaincompiler-archetype 0.3.0__tar.gz

chaincompiler_archetype-0.3.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: chaincompiler-archetype
+Version: 0.3.0
+Summary: The Archetype Compiler — archetype as state machine (Persona/Shadow/Self/Odyssey/Becoming), compiled to the one type
+Requires-Python: >=3.11
+Requires-Dist: chaincompiler==0.3.0
+Requires-Dist: click

chaincompiler_archetype-0.3.0/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "chaincompiler-archetype"
+version = "0.3.0"
+description = "The Archetype Compiler — archetype as state machine (Persona/Shadow/Self/Odyssey/Becoming), compiled to the one type"
+requires-python = ">=3.11"
+dependencies = ["chaincompiler==0.3.0", "click"]
+
+[project.scripts]
+archetype = "archetype.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

chaincompiler_archetype-0.3.0/setup.cfg

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

chaincompiler_archetype-0.3.0/src/archetype/__init__.py

@@ -0,0 +1,32 @@
+"""archetype — the Archetype Compiler. An archetype is a state machine, not a noun.
+
+    MetaArchetype(A) := ⟨ Persona(A), Shadow(A), Self(A), Odyssey(A), Becoming(A) ⟩
+
+Compiles a seed + knobs into the full individuation circuit (generating the missing
+aspects), builds the multi-HJ Odyssey, validates C1–C6, and emits through lenses —
+including the ONE TYPE, a `<name>/SKILL.md`. The ChainCompiler thesis on the psyche:
+compile the transformation law, don't list the archetypes. Spec: ARCHETYPE-COMPILER.md.
+"""
+from __future__ import annotations
+
+__version__ = "0.3.0"
+
+from .model import HJ, KNOBS, MetaArchetype, Seed
+from .stdlib import CYBERNETIC_CITY, CYCLE, PANTHEON, next_in_cycle, seed_for
+from .infer import infer, denied_inverse, integrate, type_lift
+from .odyssey import generate_odyssey, aut_web, quines
+from .validate import validate, is_valid
+from .emit import readable, triples, prolog, cypher, to_json, emit, emit_skill
+from .compile import compile_archetype, compile_chain, compile_world
+from .parser import Stmt, parse
+
+__all__ = [
+    "MetaArchetype", "HJ", "Seed", "KNOBS",
+    "CYCLE", "PANTHEON", "CYBERNETIC_CITY", "seed_for", "next_in_cycle",
+    "infer", "denied_inverse", "integrate", "type_lift",
+    "generate_odyssey", "aut_web", "quines",
+    "validate", "is_valid",
+    "readable", "triples", "prolog", "cypher", "to_json", "emit", "emit_skill",
+    "compile_archetype", "compile_chain", "compile_world",
+    "Stmt", "parse", "__version__",
+]

chaincompiler_archetype-0.3.0/src/archetype/cli.py

@@ -0,0 +1,67 @@
+"""archetype CLI (§7): compile an archetype and emit its individuation circuit.
+
+    archetype compile Hero --substrate "example world" --depth 4 --emit all
+    archetype demo
+"""
+from __future__ import annotations
+
+import click
+
+from .compile import compile_archetype, compile_chain, compile_world
+from .emit import cypher, prolog, readable, to_json, triples
+from .stdlib import CYBERNETIC_CITY, CYCLE
+from .validate import validate
+
+_LENSES = {"readable": readable, "cypher": cypher, "prolog": prolog, "json": to_json}
+
+
+@click.group()
+def main() -> None:
+    """The Archetype Compiler — archetype as state machine."""
+
+
+@main.command()
+@click.argument("name")
+@click.option("--substrate", default=None)
+@click.option("--domain", default=None)
+@click.option("--conflict", default=None)
+@click.option("--boundary", default=None)
+@click.option("--integration-mode", default=None)
+@click.option("--depth", type=int, default=None, help="how many pantheon members to visit in the Odyssey")
+@click.option("--emit", "fmt", default="readable",
+              type=click.Choice(["readable", "cypher", "prolog", "json", "triples", "all"]))
+def compile(name, substrate, domain, conflict, boundary, integration_mode, depth, fmt):
+    """Compile an archetype into its full individuation circuit."""
+    knobs = {k: v for k, v in {
+        "substrate": substrate, "domain": domain, "conflict": conflict,
+        "boundary": boundary, "integration_mode": integration_mode}.items() if v}
+    a = compile_archetype(name, knobs=knobs, depth=depth)
+    viol = validate(a)
+    if fmt == "all":
+        click.echo(readable(a, CYCLE))
+        click.echo("\n── cypher ──\n" + cypher(a))
+        click.echo("\n── prolog ──\n" + prolog(a))
+    elif fmt == "triples":
+        for s, p, o in triples(a):
+            click.echo(f"{s} —{p}→ {o}")
+    else:
+        click.echo(_LENSES[fmt](a, CYCLE) if fmt == "readable" else _LENSES[fmt](a))
+    click.echo(f"\n{'✓ valid' if not viol else '✗ ' + '; '.join(viol)}")
+
+
+@main.command()
+def demo() -> None:
+    """Compile the Hero, then the Example World world."""
+    click.echo("══ Hero — the individuation circuit + Odyssey ══")
+    a = compile_archetype("Hero", knobs={"substrate": "founder building autonomous AI"})
+    click.echo(readable(a, CYCLE))
+    click.echo(f"\nvalid: {not validate(a)}")
+
+    click.echo("\n══ Example World — a compiled world ══")
+    world = compile_world(CYBERNETIC_CITY, with_odyssey=False)
+    for nm, m in world.items():
+        click.echo(f"  {nm}: {m.persona} → ⟂{m.shadow} → ⊕{m.self_} ⇒ {m.becoming}")
+
+
+if __name__ == "__main__":
+    main()

chaincompiler_archetype-0.3.0/src/archetype/compile.py

@@ -0,0 +1,47 @@
+"""The compiler pipeline (§5): source → infer missing aspects → generate Odyssey
+(multi-HJ) → generate Becoming → recurse → validate. The headline ChainCompiler move
+applied to the psyche: you don't LIST archetypes, you compile the transformation law.
+"""
+from __future__ import annotations
+
+from .infer import infer
+from .model import MetaArchetype
+from .odyssey import generate_odyssey
+from .stdlib import CYCLE, CYBERNETIC_CITY, Seed, next_in_cycle  # noqa: F401 (re-export)
+
+
+def _pantheon(name: str, world: dict[str, Seed] | None) -> list[str]:
+    p = list(world) if world else list(CYCLE)
+    if name not in p:
+        p = [name] + p
+    return p
+
+
+def compile_archetype(name: str, *, knobs: dict | None = None,
+                      world: dict[str, Seed] | None = None, depth: int | None = None,
+                      with_odyssey: bool = True, **aspects) -> MetaArchetype:
+    """Compile one archetype: infer the five aspects, then generate its Odyssey."""
+    a = infer(name, knobs=knobs, world=world, **aspects)
+    if with_odyssey:
+        a.odyssey = generate_odyssey(a, _pantheon(name, world), world=world, depth=depth)
+    return a
+
+
+def compile_chain(names: list[str], *, knobs: dict | None = None,
+                  world: dict[str, Seed] | None = None, depth: int | None = None,
+                  with_odyssey: bool = False) -> list[MetaArchetype]:
+    """Compile an individuation chain (Hero => Guardian => King): each archetype's
+    Becoming is overridden to point at the NEXT name in the chain (C4 satisfied)."""
+    out: list[MetaArchetype] = []
+    for i, nm in enumerate(names):
+        nxt = names[i + 1] if i + 1 < len(names) else next_in_cycle(nm)
+        out.append(compile_archetype(nm, knobs=knobs, world=world, depth=depth,
+                                     with_odyssey=with_odyssey, becoming=nxt))
+    return out
+
+
+def compile_world(world: dict[str, Seed], *, knobs: dict | None = None,
+                  depth: int | None = None, with_odyssey: bool = True) -> dict[str, MetaArchetype]:
+    """Compile a whole substrate world (e.g. the Example World)."""
+    return {nm: compile_archetype(nm, knobs=knobs, world=world, depth=depth,
+                                  with_odyssey=with_odyssey) for nm in world}

chaincompiler_archetype-0.3.0/src/archetype/emit.py

@@ -0,0 +1,116 @@
+"""Emit a compiled archetype through lenses (§5, §7) — readable / triples / Prolog /
+Cypher / JSON — and, crucially, as the ONE TYPE: a `<name>/SKILL.md` skill dir, so an
+archetype is a first-class citizen of ChainCompiler's closed algebra (an archetype
+compiled to a loadable persona). Becoming = TypeLift = the recursion that, via the
+bandit, can roll the archetype up into a domain persona.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from .model import MetaArchetype
+from .odyssey import aut_web, quines
+
+
+def readable(a: MetaArchetype, pantheon: list[str] | None = None) -> str:
+    lines = [
+        f"# {a.name} — a recursive individuation circuit",
+        "",
+        f"- **Persona**  (mask):        {a.persona}",
+        f"- **Shadow**   (denied inv.): {a.shadow}",
+        f"- **Self**     (integrated):  {a.self_}",
+        f"- **Becoming** (type-lift →): {a.becoming}",
+    ]
+    if a.knobs:
+        lines += ["", "**Knobs:** " + ", ".join(f"{k}={v}" for k, v in a.knobs.items())]
+    if a.odyssey:
+        lines += ["", f"## Odyssey ({len(a.odyssey)} hero's journeys)"]
+        for i, hj in enumerate(a.odyssey):
+            lines.append(f"{i}. {hj}")
+        web = aut_web(a.odyssey)
+        lines += ["", f"**Aut-web:** {', '.join(web) if web else '—'}"]
+        if pantheon:
+            lines.append(f"**Quines the pantheon:** {quines(a.odyssey, pantheon, a.name)}")
+    if a.confidence:
+        lines += ["", "**Confidence:** " + ", ".join(f"{k}={v}" for k, v in a.confidence.items())]
+    return "\n".join(lines)
+
+
+def triples(a: MetaArchetype) -> list[tuple[str, str, str]]:
+    t = [
+        (a.name, "HAS_PERSONA", a.persona),
+        (a.name, "HAS_SHADOW", a.shadow),
+        (a.name, "HAS_SELF", a.self_),
+        (a.name, "BECOMES", a.becoming),
+        (a.shadow, "DENIED_INVERSE_OF", a.persona),
+        (a.self_, "INTEGRATES", a.persona),
+        (a.self_, "INTEGRATES", a.shadow),
+    ]
+    for hj in a.odyssey:
+        if hj.encounter:
+            t.append((a.name, "AUTOMORPHISM_EDGE", hj.encounter))
+    return t
+
+
+def prolog(a: MetaArchetype) -> str:
+    def q(s: str) -> str:
+        return s.replace("'", "\\'")
+    lines = [
+        f"persona('{q(a.name)}', '{q(a.persona)}').",
+        f"shadow('{q(a.name)}', '{q(a.shadow)}').",
+        f"self('{q(a.name)}', '{q(a.self_)}').",
+        f"becomes('{q(a.name)}', '{q(a.becoming)}').",
+        f"denied_inverse('{q(a.shadow)}', '{q(a.persona)}').",
+    ]
+    for hj in a.odyssey:
+        if hj.encounter:
+            lines.append(f"aut_edge('{q(a.name)}', '{q(hj.encounter)}').")
+    return "\n".join(lines)
+
+
+def cypher(a: MetaArchetype) -> str:
+    n = a.name
+    lines = [
+        f"MERGE (a:Archetype {{name:'{n}'}})",
+        f"SET a.persona='{a.persona}', a.shadow='{a.shadow}', a.self='{a.self_}'",
+        f"MERGE (b:Archetype {{name:'{a.becoming}'}})",
+        f"MERGE (a)-[:BECOMES]->(b)",
+    ]
+    for hj in a.odyssey:
+        if hj.encounter:
+            lines.append(f"MERGE (m:Archetype {{name:'{hj.encounter}'}}) "
+                         f"MERGE (a)-[:AUT_EDGE]->(m)")
+    return "\n".join(lines)
+
+
+def to_json(a: MetaArchetype) -> str:
+    return json.dumps({
+        "name": a.name, **a.aspects, "knobs": a.knobs,
+        "odyssey": [{"persona": h.persona, "shadow": h.shadow, "self": h.self_,
+                     "encounter": h.encounter, "post_return": h.post_return} for h in a.odyssey],
+        "aut_web": aut_web(a.odyssey), "confidence": a.confidence,
+    }, indent=2)
+
+
+def emit_skill(a: MetaArchetype, *, out_dir: str | Path, pantheon: list[str] | None = None) -> Path:
+    """Compile the archetype to the ONE type — `<name>/SKILL.md` — so it loads as a
+    persona. The body is the readable individuation circuit + its emitted graph."""
+    from chaincompiler.skillpack import write_skill
+    body = readable(a, pantheon) + "\n\n## Triples\n" + "\n".join(
+        f"- {s} —{p}→ {o}" for s, p, o in triples(a))
+    return write_skill(
+        f"{a.name}-archetype",
+        f"The {a.name} archetype as an individuation circuit (Persona/Shadow/Self → Becoming {a.becoming}).",
+        body, out_dir=out_dir, extra={"kind": "archetype", "becomes": a.becoming})
+
+
+def emit(a: MetaArchetype, fmt: str, *, pantheon: list[str] | None = None):
+    """Dispatch one lens by name."""
+    return {
+        "readable": lambda: readable(a, pantheon),
+        "triples": lambda: triples(a),
+        "prolog": lambda: prolog(a),
+        "cypher": lambda: cypher(a),
+        "json": lambda: to_json(a),
+    }[fmt]()

chaincompiler_archetype-0.3.0/src/archetype/infer.py

@@ -0,0 +1,62 @@
+"""Inference — generate the missing aspects from whichever one is known (§5).
+
+The compiler accepts a seed + knobs + (optional partial aspects) and generates the
+rest. When the name is in the stdlib pantheon, the canonical aspects are used; else
+the generic generators below produce them deterministically (no LLM — same stance as
+the rest of ChainCompiler: the mechanics are code, the content is the model's job).
+"""
+from __future__ import annotations
+
+from .model import MetaArchetype
+from .stdlib import Seed, next_in_cycle, seed_for
+
+
+# ── the three operators (generic forms; stdlib overrides with canonical content) ──
+def denied_inverse(persona: str) -> str:
+    """Shadow = DeniedInverse(Persona): the persona's virtue as its failure-mode."""
+    return f"Denied {persona} (the virtue turned to its failure-mode / projection)"
+
+
+def integrate(persona: str, shadow: str) -> str:
+    """Self = Integrate(Persona, Shadow): holds BOTH, ruled by neither."""
+    return f"Integrated form (holds «{persona}» and «{shadow}» without collapsing into either)"
+
+
+def type_lift(name: str, knobs: dict) -> str:
+    """Becoming = TypeLift(Self): the next archetype's name (knob can override)."""
+    return knobs.get("becoming") or next_in_cycle(name)
+
+
+def _scores(name: str, from_stdlib: bool, self_: str, becoming: str,
+            knobs: dict) -> dict:
+    """Deterministic confidence scores (§5: the emitted *_fit numbers)."""
+    integrates = ("holds" in self_.lower()) or ("integrat" in self_.lower())
+    return {
+        "persona_shadow_fit": 1.0 if from_stdlib else 0.6,
+        "self_integration_fit": 1.0 if integrates else 0.3,   # purified-Self penalty
+        "becoming_fit": 1.0 if becoming and becoming != name else 0.0,
+        "substrate_fit": 1.0 if knobs.get("substrate") else 0.5,
+        "nonredundancy": 1.0 if becoming != name else 0.0,
+    }
+
+
+def infer(name: str, *, knobs: dict | None = None, world: dict[str, Seed] | None = None,
+          persona: str | None = None, shadow: str | None = None,
+          self_: str | None = None, becoming: str | None = None) -> MetaArchetype:
+    """Build a (still odyssey-less) MetaArchetype, filling unknown aspects.
+
+    Precedence per aspect: explicit arg > stdlib seed > generic generator. This is
+    the §5 "if-X-known → generate the rest" table collapsed into one resolver.
+    """
+    knobs = dict(knobs or {})
+    seed = seed_for(name, world)
+    from_stdlib = seed is not None
+
+    p = persona or (seed.persona if seed else f"{name} (legible role)")
+    s = shadow or (seed.shadow if seed else denied_inverse(p))
+    i = self_ or (seed.self_ if seed else integrate(p, s))
+    b = becoming or (seed.becoming if seed else type_lift(name, knobs))
+
+    return MetaArchetype(name=name, persona=p, shadow=s, self_=i, becoming=b,
+                         odyssey=[], knobs=knobs,
+                         confidence=_scores(name, from_stdlib, i, b, knobs))

chaincompiler_archetype-0.3.0/src/archetype/model.py

@@ -0,0 +1,68 @@
+"""The archetype-as-state-machine model (ARCHETYPE-COMPILER.md §1, §3).
+
+An archetype is NOT a noun (a role label) but a recursive individuation circuit:
+
+    MetaArchetype(A) := ⟨ Persona(A), Shadow(A), Self(A), Odyssey(A), Becoming(A) ⟩
+
+- Persona  = the legible / claimed face (the mask).
+- Shadow   = DeniedInverse(Persona) — the failure-mode / projected inverse.
+- Self     = Integrate(Persona, Shadow) — contains BOTH, ruled by neither
+             (a *purified* Persona that bypasses the Shadow is the cardinal error).
+- Odyssey  = the SUCCESSION of hero's journeys (§2) — plural, accrues the pantheon
+             automorphism-web, ends in quining (orbit-closure).
+- Becoming = TypeLift(Self) — the integrated Self becomes the Persona of the next
+             archetype. One Becoming = one hero's journey = one modulation.
+
+These mechanics are G0-by-definition *inside the calculus*. The music-theory frame
+(circle of fifths ↔ Becoming-cycle, etc.) is a G8 organizing resonance — see
+ARCHETYPE-COMPILER.md §0; it is NOT asserted by this code.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+# the generation knobs (= "modes"): each colors one archetype differently.
+KNOBS = ("domain", "substrate", "conflict", "boundary", "integration_mode", "scale", "tone")
+
+
+@dataclass
+class HJ:
+    """One hero's journey = one Becoming step (Persona-state → Shadow → Self ⇒ next).
+    In an Odyssey, each non-zero HJ is an automorphism-encounter with a pantheon
+    member (`encounter`): A meets B as an image of itself (one sense, many faces)."""
+    persona: str
+    shadow: str
+    self_: str
+    encounter: str = ""          # the pantheon member met as an automorphism-image
+    post_return: bool = False    # the post-return HJ (arrival ≠ completion; the suitors)
+
+    def __str__(self) -> str:
+        tag = " [post-return]" if self.post_return else (f" ↔{self.encounter}" if self.encounter else "")
+        return f"{self.persona} → ⟂{self.shadow} → ⊕{self.self_}{tag}"
+
+
+@dataclass
+class MetaArchetype:
+    """A compiled archetype: the five aspects + the knobs that colored it + scores."""
+    name: str
+    persona: str
+    shadow: str
+    self_: str
+    becoming: str                          # the name of the next archetype (TypeLift target)
+    odyssey: list[HJ] = field(default_factory=list)
+    knobs: dict = field(default_factory=dict)
+    confidence: dict = field(default_factory=dict)
+
+    @property
+    def aspects(self) -> dict:
+        return {"persona": self.persona, "shadow": self.shadow,
+                "self": self.self_, "becoming": self.becoming}
+
+
+@dataclass
+class Seed:
+    """A stdlib pantheon entry — the canonical four aspects of one archetype."""
+    persona: str
+    shadow: str
+    self_: str
+    becoming: str

chaincompiler_archetype-0.3.0/src/archetype/odyssey.py

@@ -0,0 +1,66 @@
+"""The Odyssey — a SUCCESSION of hero's journeys (ARCHETYPE-COMPILER.md §2).
+
+The original spec's bug: it made an Odyssey a single Persona→Shadow→Self path. That
+is ONE hero's journey = ONE Becoming, not an Odyssey. An Odyssey is plural:
+
+    HJ₀          the call-out journey (leave home / Troy)
+    HJ₁…HJₙ      the wandering arcs — each an automorphism-encounter with a pantheon
+                 member (A meets B as an image of itself; accrues the Aut-web)
+    HJ_return    the POST-return mini-HJ (you arrive home and STILL must fight — the
+                 suitors; arrival ≠ completion)
+
+The telos = accrue an automorphism-edge to every pantheon member → orbit-closure →
+quine the pantheon. Whether the orbit actually CLOSES (vs only tempering) is the open
+seam (see ARCHETYPE-MUSIC-CORRESPONDENCE-MAP.md); this generator builds the
+succession, it does not claim closure.
+"""
+from __future__ import annotations
+
+from .model import HJ, MetaArchetype
+from .stdlib import Seed, seed_for
+
+
+def generate_odyssey(arch: MetaArchetype, pantheon: list[str], *,
+                     world: dict[str, Seed] | None = None,
+                     depth: int | None = None) -> list[HJ]:
+    """Build A's odyssey: a call-out HJ, one encounter-HJ per other pantheon member
+    (up to `depth`), and a post-return HJ. Each encounter accrues an Aut-edge."""
+    hjs: list[HJ] = []
+
+    # HJ₀ — the call-out: A's own Persona → Shadow → Self
+    hjs.append(HJ(persona=arch.persona, shadow=arch.shadow, self_=arch.self_,
+                  encounter=""))
+
+    # HJ₁…HJₙ — meet each OTHER pantheon member as an automorphism-image of A
+    others = [m for m in pantheon if m != arch.name]
+    if depth is not None:
+        others = others[:max(0, depth)]
+    carry = arch.self_
+    for m in others:
+        ms = seed_for(m, world)
+        m_shadow = ms.shadow if ms else f"the shadow of {m}"
+        hjs.append(HJ(
+            persona=carry,                                   # carry the prior Self forward
+            shadow=m_shadow,                                 # confront M's shadow-face
+            self_=f"{arch.name}-as-{m} (A's {m}-automorphism)",
+            encounter=m))
+        carry = f"{arch.name}+{m}"
+
+    # HJ_return — the post-return journey (the suitors): integrate the homecoming
+    hjs.append(HJ(persona=carry, shadow=f"the unguarded home ({arch.name} returned but untested)",
+                  self_=f"{arch.name} sovereign at home (return integrated)",
+                  encounter="", post_return=True))
+    return hjs
+
+
+def aut_web(odyssey: list[HJ]) -> list[str]:
+    """The set of pantheon members A has accrued an automorphism-edge to."""
+    return [hj.encounter for hj in odyssey if hj.encounter]
+
+
+def quines(odyssey: list[HJ], pantheon: list[str], name: str) -> bool:
+    """Orbit-closure test (the telos): has A met EVERY other pantheon member?
+    True ⇒ A can regenerate the whole pantheon from itself (quining). This is the
+    discrete closure check; it does NOT settle the comma/tempering question."""
+    met = set(aut_web(odyssey))
+    return met >= {m for m in pantheon if m != name}

chaincompiler_archetype-0.3.0/src/archetype/parser.py

@@ -0,0 +1,42 @@
+"""Parse the archetype DSL (§7) into structured requests.
+
+    archetype Hero { substrate:"founder building AI" domain:"startup myth"
+                     conflict:"inflation" boundary:"responsibility" integration_mode:"service" }
+    chain IndividuationPath { Hero => Guardian => King => Steward => Sage }
+    triangulate { X==Shadow  Y==Persona  Z==Self }
+
+Returns a list of `Stmt` (kind ∈ {archetype, chain, triangulate}); the CLI/compiler
+consume them. Deliberately tiny — regex over braces, no external grammar.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+_BLOCK = re.compile(r"(archetype|chain|triangulate)\s+([A-Za-z0-9_]+)?\s*\{([^}]*)\}", re.S)
+_KV = re.compile(r"([A-Za-z_]+)\s*:\s*\"([^\"]*)\"")
+_ARROW = re.compile(r"=>")
+_ANCHOR = re.compile(r"([A-Za-z0-9_]+)\s*==\s*(Persona|Shadow|Self)", re.I)
+
+
+@dataclass
+class Stmt:
+    kind: str                       # archetype | chain | triangulate
+    name: str = ""
+    knobs: dict = field(default_factory=dict)        # for `archetype`
+    steps: list[str] = field(default_factory=list)   # for `chain`
+    anchors: dict = field(default_factory=dict)       # for `triangulate`: {role: var}
+
+
+def parse(text: str) -> list[Stmt]:
+    stmts: list[Stmt] = []
+    for kind, name, inner in _BLOCK.findall(text):
+        if kind == "archetype":
+            stmts.append(Stmt("archetype", name, knobs=dict(_KV.findall(inner))))
+        elif kind == "chain":
+            steps = [s.strip() for s in _ARROW.split(inner) if s.strip()]
+            stmts.append(Stmt("chain", name, steps=steps))
+        elif kind == "triangulate":
+            anchors = {role.capitalize(): var for var, role in _ANCHOR.findall(inner)}
+            stmts.append(Stmt("triangulate", name, anchors=anchors))
+    return stmts

chaincompiler_archetype-0.3.0/src/archetype/stdlib.py

@@ -0,0 +1,53 @@
+"""The seed pantheon + the default Becoming-cycle (ARCHETYPE-COMPILER.md §4).
+
+The default Becoming-cycle CLOSES into a circle (the "circle of fifths of the psyche"):
+
+    Fool → Seeker → Hero → Guardian → King → Steward → Sage → Witness → Self ↺
+
+Whether that closure is exact or only *tempers* (the circle-of-fifths never closes:
+3¹² ≠ 2¹⁹) is the one open seam — see ARCHETYPE-MUSIC-CORRESPONDENCE-MAP.md. This
+table just gives the canonical aspects; it does not assert the music correspondence.
+"""
+from __future__ import annotations
+
+from .model import Seed
+
+# the default cycle (each Becoming points to the next; Self closes back to Fool)
+CYCLE = ["Fool", "Seeker", "Hero", "Guardian", "King", "Steward", "Sage", "Witness", "Self"]
+
+PANTHEON: dict[str, Seed] = {
+    "Fool":     Seed("Innocent beginner",     "Naive Dupe (folly mistaken for wisdom)",  "Wise Innocent (open, not gullible)",        "Seeker"),
+    "Seeker":   Seed("Restless searcher",     "Lost Wanderer (seeking as avoidance)",    "Grounded Seeker (searches without fleeing)", "Hero"),
+    "Hero":     Seed("Rescuer / champion",    "Savior-Overlord (courage→domination)",    "Guardian Process (holds courage AND its shadow)", "Guardian"),
+    "Guardian": Seed("Boundary maintainer",   "Access Tyrant (care→exclusion)",          "Protocol Steward (guards without gatekeeping)", "King"),
+    "King":     Seed("Sovereign ruler",       "Despot (sovereignty→tyranny)",            "Servant-Sovereign (rules in service)",      "Steward"),
+    "Steward":  Seed("Caretaker of the order","Frozen Bureaucrat (order→rigidity)",      "Living Constitution (order that adapts)",   "Sage"),
+    "Sage":     Seed("Knower / reflector",    "Detached Cynic (wisdom→contempt)",        "Embodied Sage (knows AND acts)",            "Witness"),
+    "Witness":  Seed("Pure observer",         "Passive Spectator (witness→abdication)",  "Engaged Witness (sees AND participates)",    "Self"),
+    "Self":     Seed("Integrated wholeness",  "Inflated Guru (wholeness→ego)",           "Quiet Self (whole, unclaimed)",             "Fool"),  # closes
+    # off-cycle (the Jester thread, §8): Trickster.Self = Jester; Trickster.Shadow = clown.
+    "Trickster":Seed("Liberator / sacred fool","Demon Clown (renewal→sabotage)",         "Jester (renewal through disruption)",       "Magician"),
+    "Magician": Seed("Transformer",           "Manipulator (power→exploitation)",        "True Magician (transforms in service)",     "Sage"),
+}
+
+# a worked substrate instantiation: the "Example World" generation.
+CYBERNETIC_CITY: dict[str, Seed] = {
+    "Hero":       Seed("Debug Champion",     "Savior-Overlord",      "Guardian Process",    "Gatekeeper"),
+    "Gatekeeper": Seed("Boundary Maintainer","Access Tyrant",        "Protocol Steward",    "Lawgiver"),
+    "Lawgiver":   Seed("Rule Compiler",      "Frozen Bureaucracy",   "Living Constitution", "Sovereign Kernel"),
+}
+
+
+def seed_for(name: str, world: dict[str, Seed] | None = None) -> Seed | None:
+    """Look up a canonical seed (a named world overrides the default pantheon)."""
+    if world and name in world:
+        return world[name]
+    return PANTHEON.get(name)
+
+
+def next_in_cycle(name: str) -> str:
+    """The default Becoming target for `name` (wraps; off-cycle → its seed's becoming)."""
+    if name in CYCLE:
+        return CYCLE[(CYCLE.index(name) + 1) % len(CYCLE)]
+    s = PANTHEON.get(name)
+    return s.becoming if s else "Self"

chaincompiler_archetype-0.3.0/src/archetype/validate.py

@@ -0,0 +1,56 @@
+"""Graph constraints C1–C6 (ARCHETYPE-COMPILER.md §5, §2.4).
+
+C1  Persona-opposes-Shadow      (shadow ≠ persona; it is the denied inverse)
+C2  Self-contains-both          (NOT a purified Persona that bypasses the Shadow)
+C3  Odyssey-traverses-Shadow    (every HJ confronts a shadow)
+C4  Becoming-type-lifts         (becoming ≠ the archetype itself; it explains A⇒B)
+C5  recursion terminates/cycles (becoming resolves to a known/own name)
+C6  Odyssey-is-plural           (≥1 HJ AND accrues automorphism-edges)
+C6b post-return present         (a complete Odyssey returns AND fights again)
+
+`validate` returns a list of violation strings; empty ⇒ the archetype is well-formed.
+"""
+from __future__ import annotations
+
+from .model import MetaArchetype
+from .odyssey import aut_web
+
+
+def validate(arch: MetaArchetype) -> list[str]:
+    v: list[str] = []
+
+    # C1 — persona opposes shadow
+    if not arch.shadow or arch.shadow.strip() == arch.persona.strip():
+        v.append("C1: Shadow must be the denied inverse of Persona (got identical/empty).")
+
+    # C2 — Self contains both (the cardinal error: a purified Persona)
+    sl = arch.self_.strip().lower()
+    if arch.self_.strip() == arch.persona.strip():
+        v.append("C2: Self is a purified Persona (identical) — it must integrate the Shadow.")
+    elif not ("hold" in sl or "integrat" in sl or "both" in sl or "-as-" in sl
+              or arch.name.lower() in sl):
+        v.append("C2: Self does not evidence integration of Persona AND Shadow.")
+
+    # C4 — Becoming type-lifts to a different archetype
+    if not arch.becoming or arch.becoming.strip() == arch.name.strip():
+        v.append("C4: Becoming must type-lift to a DIFFERENT archetype (got self/empty).")
+
+    # odyssey constraints (only when an odyssey was generated)
+    if arch.odyssey:
+        # C3 — every HJ traverses a shadow
+        if any(not hj.shadow.strip() for hj in arch.odyssey):
+            v.append("C3: every hero's journey in the Odyssey must confront a Shadow.")
+        # C6 — plural AND accrues automorphism-edges
+        if len(arch.odyssey) < 2:
+            v.append("C6: an Odyssey is a SUCCESSION of HJs (a single P→S→Self is a Becoming).")
+        if not aut_web(arch.odyssey):
+            v.append("C6: the Odyssey must accrue automorphism-edges to other pantheon members.")
+        # C6b — post-return HJ present
+        if not any(hj.post_return for hj in arch.odyssey):
+            v.append("C6b: a complete Odyssey includes a post-return journey (arrival ≠ completion).")
+
+    return v
+
+
+def is_valid(arch: MetaArchetype) -> bool:
+    return not validate(arch)

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

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: chaincompiler-archetype
+Version: 0.3.0
+Summary: The Archetype Compiler — archetype as state machine (Persona/Shadow/Self/Odyssey/Becoming), compiled to the one type
+Requires-Python: >=3.11
+Requires-Dist: chaincompiler==0.3.0
+Requires-Dist: click

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

@@ -0,0 +1,18 @@
+pyproject.toml
+src/archetype/__init__.py
+src/archetype/cli.py
+src/archetype/compile.py
+src/archetype/emit.py
+src/archetype/infer.py
+src/archetype/model.py
+src/archetype/odyssey.py
+src/archetype/parser.py
+src/archetype/stdlib.py
+src/archetype/validate.py
+src/chaincompiler_archetype.egg-info/PKG-INFO
+src/chaincompiler_archetype.egg-info/SOURCES.txt
+src/chaincompiler_archetype.egg-info/dependency_links.txt
+src/chaincompiler_archetype.egg-info/entry_points.txt
+src/chaincompiler_archetype.egg-info/requires.txt
+src/chaincompiler_archetype.egg-info/top_level.txt
+tests/test_archetype.py

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

@@ -0,0 +1 @@
+

chaincompiler_archetype-0.3.0/src/chaincompiler_archetype.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+archetype = archetype.cli:main

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

@@ -0,0 +1,2 @@
+chaincompiler==0.3.0
+click

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

@@ -0,0 +1 @@
+archetype

chaincompiler_archetype-0.3.0/tests/test_archetype.py

@@ -0,0 +1,92 @@
+"""Tests for the Archetype Compiler — the spec's MVP test list (§7) + the ✦new ones."""
+from __future__ import annotations
+
+import json
+import tempfile
+
+import archetype as arc
+
+
+# ── the preserved MVP tests ──────────────────────────────────────────────────
+def test_hero_becomes_guardian():
+    a = arc.compile_archetype("Hero")
+    assert a.becoming == "Guardian"
+
+
+def test_shadow_opposes_persona():
+    a = arc.compile_archetype("Hero")
+    assert a.shadow and a.shadow != a.persona
+    assert ("DENIED_INVERSE_OF", a.persona) in [(p, o) for s, p, o in arc.triples(a)
+                                                if p == "DENIED_INVERSE_OF"][0:1] or True
+    assert (a.shadow, "DENIED_INVERSE_OF", a.persona) in arc.triples(a)
+
+
+def test_self_integrates_both():
+    a = arc.compile_archetype("Hero")
+    assert (a.self_, "INTEGRATES", a.persona) in arc.triples(a)
+    assert (a.self_, "INTEGRATES", a.shadow) in arc.triples(a)
+    assert arc.is_valid(a)
+
+
+def test_recursive_depth():
+    chain = arc.compile_chain(["Hero", "Guardian", "King", "Steward", "Sage"])
+    assert [m.name for m in chain] == ["Hero", "Guardian", "King", "Steward", "Sage"]
+    # each Becoming points at the next link (the chain type-lifts forward)
+    assert [m.becoming for m in chain[:-1]] == ["Guardian", "King", "Steward", "Sage"]
+
+
+def test_purified_self_fails():
+    # a Self that is just the Persona (bypasses the Shadow) must be a C2 violation
+    bad = arc.compile_archetype("Hero", with_odyssey=False, self_="Rescuer / champion",
+                                persona="Rescuer / champion")
+    v = arc.validate(bad)
+    assert any(x.startswith("C2") for x in v)
+
+
+# ── ✦new tests (the Odyssey refactor) ────────────────────────────────────────
+def test_odyssey_is_plural():
+    a = arc.compile_archetype("Hero")
+    # a real Odyssey is a SUCCESSION (call-out + encounters + post-return), not 1 HJ
+    assert len(a.odyssey) >= 2
+    assert arc.is_valid(a)
+
+
+def test_odyssey_accrues_pantheon_edges():
+    a = arc.compile_archetype("Hero")
+    web = arc.aut_web(a.odyssey)
+    assert len(web) >= 1
+    # visiting the full pantheon ⇒ quines it (orbit-closure, discrete check)
+    full = arc.compile_archetype("Hero")  # default depth = all others
+    assert arc.quines(full.odyssey, arc.CYCLE, "Hero")
+
+
+def test_post_return_hj_present():
+    a = arc.compile_archetype("Hero")
+    assert any(hj.post_return for hj in a.odyssey), "C6b: an Odyssey returns AND fights again"
+
+
+# ── emit + parse + skill-dir (the one type) ──────────────────────────────────
+def test_emit_lenses():
+    a = arc.compile_archetype("King")
+    assert "MERGE" in arc.cypher(a)
+    assert "becomes(" in arc.prolog(a)
+    assert json.loads(arc.to_json(a))["name"] == "King"
+
+
+def test_parse_dsl():
+    src = 'archetype Hero { substrate:"AI" domain:"startup" }\nchain Path { Hero => Guardian => King }'
+    stmts = arc.parse(src)
+    kinds = {s.kind for s in stmts}
+    assert kinds == {"archetype", "chain"}
+    hero = [s for s in stmts if s.kind == "archetype"][0]
+    assert hero.knobs["substrate"] == "AI"
+    path = [s for s in stmts if s.kind == "chain"][0]
+    assert path.steps == ["Hero", "Guardian", "King"]
+
+
+def test_emit_skill_is_the_one_type():
+    a = arc.compile_archetype("Hero")
+    out = tempfile.mkdtemp(prefix="arc_skill_")
+    p = arc.emit_skill(a, out_dir=out, pantheon=arc.CYCLE)
+    assert p.exists() and p.name == "SKILL.md"
+    assert "Becoming" in p.read_text()