personacc 0.3.0__tar.gz

personacc-0.3.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: personacc
+Version: 0.3.0
+Summary: Persona Compiler-Compiler — compiles a persona bundle (description blocks + attention chains + ≥1 chain-of-reasoning that uses them) and seats it into make_gba
+Requires-Python: >=3.11
+Requires-Dist: chaincompiler-accc==0.3.0
+Requires-Dist: corcc==0.3.0
+Requires-Dist: chaincompiler==0.3.0

personacc-0.3.0/README.md

@@ -0,0 +1,81 @@
+# PersonaCC — Persona Compiler-Compiler
+
+The **persona** compiler of the cognition-chain stack: `ACCC → CORCC → PersonaCC`.
+
+## The ratified definition
+
+> **A persona = a specific set of DESCRIPTION BLOCKS + a set of ACs + at least one
+> CoR that USES them.**
+
+ACCC forges an **attention chain** (inner, silent — *how to think*). CORCC forges a
+**chain-of-reasoning** (outer, spoken — the persona-melt gauge). PersonaCC forges
+the whole **persona**: the description blocks that say who the agent is, the
+attention chains it thinks along, and the one-or-more CoRs that use them. Its
+source language is the 2023 SDNA-template block grammar (`[KIND] … [/KIND]`).
+
+## The bundle (`notation.py`)
+
+```python
+Block(kind="role", body="You are …")          # kind is a FREE string — new kinds are legal
+PersonaBundle(
+    name="…",
+    blocks=(Block(...), …),                    # description blocks (may be empty)
+    acs=("[Focus] ⇒ [Focus] ⇒ |Held|", …),     # attention chains (accc notation)
+    cors=(persona_spec, …),                    # ≥1 corcc.PersonaSpec (the reasoning core)
+    blurb="…",
+)
+```
+
+`PersonaSpec` is really the **COR SPEC** (a half-persona — the spoken move-chain);
+PersonaCC builds the full persona *above* it. New block kinds are legal by design
+(the template-template rule): the grammar never closes over a fixed enum.
+
+## The *CC shape (`forge.py`)
+
+- **`forge_bundle(bundle, db=…)`** — forge each AC via ACCC, each CoR via CORCC;
+  run the notation lint + the uses-them gate. Returns a `ForgedBundle`.
+- **`lint(bundle)`** — notation/structure lint: every AC is a well-formed rune
+  chain, every CoR chain parses, ≥1 CoR, blocks well-formed.
+- **`uses_them(bundle, strict=False)`** — the check that makes "…that USES them"
+  mechanical: every CoR move name must be a focus in a bundle AC **or** the CoR's
+  own derived chain. The escape hatch (a CoR's own derived chain always contains
+  its own moves) means a well-formed bundle never hard-fails in the default mode —
+  uncovered moves surface as **warnings** ("declared but not wired to an AC").
+  `strict=True` drops the escape hatch: an uncovered move is a **violation**.
+  (Weakened to a warning by default because the seed/proof bundles' real attention
+  atoms legitimately don't re-list every CoR move.)
+- **`package(bundle, out_dir)`** — compile to `<name>/SKILL.md` (blocks as
+  sections + the AC set + each CoR's PRIME) via `chaincompiler.write_skill`.
+- **`seat(bundle)`** — return exactly the kwargs
+  `chainaios.make_gba(domain, root, **seat(bundle))` accepts:
+  `{atoms, blurb, role_block, persona}`. Only `cors[0]` is seated today; seating
+  additional CoRs is future work.
+
+## TOTAL SYNTAXIFICATION (the doctrine)
+
+One notation all the way down: **every persona block can be made with AC syntax, and
+natural language never appears free — only as a component the specific AC syntax
+licenses** (e.g. a condition gloss inside a focus). Blocks therefore carry a **grade**
+(`Block.grade`): `prose` (soup — free NL, tolerated *only* for migration) → `chain`
+(code — real chain syntax). Detection is honest — for the default `rune` language it
+uses accc's **real parser** (`parse_ac`), not a regex; a body is a chain iff it parses.
+The **melt-gauge** that CORCC runs on a CoR (forge the language, gate the text, drift =
+melting) now runs on the whole persona: `forge.lint_blocks(bundle)` gates every
+chain-graded block (a hard issue if it melts) and warns on every prose block
+("unsyntactified block: <kind>"). A malformed chain-block fires the same gate a melting
+CoR does. The endpoint: the melt-gauge covers the entire persona, not just its CoRs.
+
+**TYPE ⊥ SYNTAX.** A block is a triple — (type-`kind`, `lang`, `body` string): the
+label is orthogonal to the language is orthogonal to the string. The typed content is
+canonical; **every string is a *render*** of it in some chain language, and
+re-rendering one typed corpus across languages IS the de-lore/masking mechanism —
+myth-lang and research-lang are two render targets of the same typed persona. A
+language is lintable once its melt-gauge is registered (`register_lang_gate(name, fn)`;
+`LANG_GATES` holds `rune` by default); until then its blocks grade `prose` ("no gate
+registered for lang=<x>"). To emit a conformant string, the LLM needs only the type
+label + which syntax.
+
+## The library
+
+`personapack` is the LIBRARY of pre-bound `PersonaBundle`s (Bodhisattva, Aegis,
+SamayaReviewer, …), each with an honest activation grade and a receipt.

personacc-0.3.0/pyproject.toml

@@ -0,0 +1,13 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "personacc"
+version = "0.3.0"
+description = "Persona Compiler-Compiler — compiles a persona bundle (description blocks + attention chains + ≥1 chain-of-reasoning that uses them) and seats it into make_gba"
+requires-python = ">=3.11"
+dependencies = ["chaincompiler-accc==0.3.0", "corcc==0.3.0", "chaincompiler==0.3.0"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

personacc-0.3.0/setup.cfg

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

personacc-0.3.0/src/personacc/__init__.py

@@ -0,0 +1,32 @@
+"""PersonaCC — Persona Compiler-Compiler. The syntax compiler for a PERSONA.
+
+THE RATIFIED DEFINITION: a persona = a set of DESCRIPTION BLOCKS + a set of ACs +
+at least one CoR that USES them. PersonaCC compiles that bundle: catch the
+notation → lint (form + "uses them") → compile to a markdown body → package as
+`<name>/SKILL.md` → SEAT into `chainaios.make_gba(persona=…)`. Composes ACCC (the
+attention chains) + CORCC (the chains of reasoning). ACCC → CORCC → PersonaCC.
+"""
+from __future__ import annotations
+
+__version__ = "0.3.0"
+
+from .notation import Block, PersonaBundle
+from .forge import (
+    ForgedBundle,
+    LANG_GATES,
+    forge_bundle,
+    lint,
+    lint_blocks,
+    package,
+    register_lang_gate,
+    render_blocks,
+    role_block,
+    seat,
+    uses_them,
+)
+
+__all__ = [
+    "Block", "PersonaBundle", "ForgedBundle",
+    "forge_bundle", "lint", "lint_blocks", "uses_them", "package", "seat",
+    "render_blocks", "role_block", "register_lang_gate", "LANG_GATES", "__version__",
+]

personacc-0.3.0/src/personacc/forge.py

@@ -0,0 +1,390 @@
+"""PersonaCC — the Persona Compiler-Compiler. Composes ACCC + CORCC.
+
+Same *CC shape as ACCC / CORCC / SCCC: catch the notation, LINT it (so the model
+never emits a malformed persona), compile it to a markdown body, and PACKAGE that
+as `<name>/SKILL.md`. PersonaCC judges no content — only the SYNTAX and the
+STRUCTURE of the bundle (the ratified definition: blocks + ACs + ≥1 CoR that uses
+them).
+
+Where it sits: ACCC forges an attention chain; CORCC forges a CoR (embedding an
+AC); PersonaCC forges the whole PERSONA (a set of blocks + ACs + ≥1 CoR that uses
+them) and SEATS it into `chainaios.make_gba(persona=…)`. ACCC → CORCC → PersonaCC.
+
+The headline check is `uses_them` — the lint that makes the "…that USES them"
+clause of the definition mechanically checkable. See its docstring for the rule
+and the honest weakening.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+import tempfile
+
+from accc import Language as ACLanguage
+from accc import forge as ac_forge
+from accc import gate as ac_gate
+from accc import parse_ac
+from corcc import Persona, cor_chain, forge_persona, inner_template, prime as cor_prime
+from chaincompiler import slugify, write_skill  # made FROM CC (CC re-exports APE's write_skill/slugify)
+
+from .notation import Block, PersonaBundle
+
+
+# ── notation helpers ─────────────────────────────────────────────────────────
+def _focus_set(chains: list[str]) -> set[str]:
+    """Every focus (ordered `[Focus]` term AND the `|Held|`) across the chains."""
+    foci: set[str] = set()
+    for ch in chains:
+        try:
+            ordered, held = parse_ac(ch)
+        except Exception:
+            continue  # malformed chains are caught by `lint`, not here
+        foci.update(ordered)
+        if held:
+            foci.add(held)
+    return foci
+
+
+def _derived_focus_set(bundle: PersonaBundle) -> set[str]:
+    """The union of every CoR's OWN derived chain foci (= all its move names)."""
+    return _focus_set([cor_chain(cor) for cor in bundle.cors])
+
+
+# ── the notation lint (syntax + structure) ───────────────────────────────────
+def lint(bundle: PersonaBundle) -> list[str]:
+    """Syntax/structure lint of a persona bundle's NOTATION (the *CC check).
+
+    Checks, without judging any content:
+      - every AC string is a well-formed rune attention chain (parseable, has a
+        bounded `|Held|`);
+      - every CoR's derived chain is well-formed;
+      - the bundle has ≥1 CoR and every block has a non-empty kind.
+
+    Returns a list of human-readable issue strings (empty = clean notation). This
+    is the "is it well-formed?" gate; the "does the CoR use the ACs?" gate is the
+    separate `uses_them` below.
+    """
+    issues: list[str] = []
+    if not bundle.cors:
+        issues.append("bundle has no CoR (a persona needs ≥1 CoR)")
+    for i, ac in enumerate(bundle.acs):
+        try:
+            _, held = parse_ac(ac)
+        except Exception as e:
+            issues.append(f"AC[{i}] {ac!r}: not a well-formed attention chain ({e})")
+            continue
+        if not held:
+            issues.append(f"AC[{i}] {ac!r}: no bounded |Held| convergence")
+    for cor in bundle.cors:
+        chain = cor_chain(cor)
+        try:
+            parse_ac(chain)
+        except Exception as e:
+            issues.append(f"CoR {cor.name!r} derived chain {chain!r}: malformed ({e})")
+    for b in bundle.blocks:
+        if not b.kind.strip():
+            issues.append("a block has an empty kind")
+    # TOTAL SYNTAXIFICATION: a chain-graded block that MELTS its own gauge is a hard
+    # notation issue (folded in here). Prose blocks are only WARNINGS (soup is tolerated
+    # for migration), so they ride the warnings channel of `lint_blocks` — folding them
+    # in as issues would wrongly fail every migration-era bundle.
+    block_issues, _block_warnings = lint_blocks(bundle)
+    issues.extend(block_issues)
+    return issues
+
+
+# ── the language-gate registry (TYPE ⊥ SYNTAX) ───────────────────────────────
+# A block is (type, LANGUAGE, string). Each chain LANGUAGE carries its own melt-gauge:
+# a callable `gate(body: str) -> list[str]` returning violation strings (empty = clean).
+# "rune" is the built-in honeyc Dense Rune-Chain gauge; new languages register here.
+
+def _rune_gate(body: str) -> list[str]:
+    """The 'rune' language gate = the block melt-gauge (the SAME gauge CORCC uses on a CoR).
+
+    CORCC forges an accc Language from a CoR's canonical `cor_chain(spec)` and gates the
+    spoken CoR text against it (`corcc.lint` = `ac_gate(persona.inner, cor_text)`); drift
+    out of the syntax = the persona "melting". The block analogue: the block IS its own
+    notation, so we forge the Language from the block's CLEAN rune skeleton (the canonical
+    chain `parse_ac` recovers) and gate the RAW body against it. A clean chain equals its
+    skeleton → 0 violations; a body that hides prose between foci, misplaces the `|Held|`,
+    or drops a `⇒` drifts from the skeleton → the gate fires. The forge needs a scratch DB
+    (the gate is only defined against a forged Language — the forge-backed check, stated
+    plainly), so a throwaway temp DB is used and discarded per call.
+    """
+    foci, held = parse_ac(body)  # body is rune-chain-graded, so this succeeds
+    canonical = " ⇒ ".join(f"[{f}]" for f in foci)
+    if held:
+        canonical += f" ⇒ |{held}|"
+    with tempfile.TemporaryDirectory() as tmp:
+        language = ac_forge("rune-block-gate", [canonical], db=str(Path(tmp) / "rune-gate.db"))
+        violations, _warnings = ac_gate(language, body)
+    if violations:
+        return [f"{len(violations)} violation(s) vs its rune skeleton {canonical!r}"]
+    return []
+
+
+LANG_GATES: dict[str, callable] = {"rune": _rune_gate}
+
+
+def register_lang_gate(name: str, fn) -> None:
+    """Register a melt-gauge for a chain LANGUAGE: `fn(body: str) -> list[str]` (violations).
+
+    TYPE ⊥ SYNTAX: registering a gate makes a language LINTABLE — blocks written in it
+    then grade "chain" and are melt-gauged like any rune block. Until a language has a
+    gate it is unlintable = soup-grade (its blocks grade "prose")."""
+    LANG_GATES[name] = fn
+
+
+def lint_blocks(bundle: PersonaBundle) -> tuple[list[str], list[str]]:
+    """Block-level syntaxification gate → `(issues, warnings)`, dispatched by `lang`.
+
+    For each description block, split on its `grade`:
+      - "chain" → run the language's registered melt-gauge (`LANG_GATES[block.lang]`, the
+        same gauge CORCC uses on a CoR). A chain block that drifts out of its language's
+        syntax is a hard ISSUE.
+      - "prose" → a WARNING: "unsyntactified block: <kind>" for an unparsed rune body, or
+        "no gate registered for lang=<x>" for a block in an unknown (unlintable) language.
+        Tolerated soup, but flagged so the migration to one-notation-all-the-way-down is
+        visible.
+
+    Mirrors `uses_them`'s (violations, warnings) split.
+    """
+    issues: list[str] = []
+    warnings: list[str] = []
+    for b in bundle.blocks:
+        if b.grade == "chain":
+            gate = LANG_GATES.get(b.lang)
+            if gate is None:  # defensive: grade==chain implies a gate exists, but be safe
+                warnings.append(f"no gate registered for lang={b.lang}")
+                continue
+            for v in gate(b.body):
+                issues.append(f"block {b.kind!r} (lang={b.lang}) MELTS the gate: {v}")
+        elif b.lang != "rune" and b.lang not in LANG_GATES:
+            warnings.append(f"no gate registered for lang={b.lang}")
+        else:
+            warnings.append(f"unsyntactified block: {b.kind}")
+    return issues, warnings
+
+
+# ── the "…that USES them" lint (the headline check) ──────────────────────────
+def uses_them(bundle: PersonaBundle, *, strict: bool = False) -> tuple[list[str], list[str]]:
+    """Check the "…that USES them" clause of the persona definition.
+
+    THE RULE (as ratified):
+        Every CoR move name must appear as a FOCUS in at least one of the bundle's
+        AC chains, OR in the CoR's OWN derived chain (`corcc.cor_chain(cor)`).
+
+    Honest implementation note (the weakening, stated loudly). A CoR's own derived
+    chain is `[m0] ⇒ [m1] ⇒ … ⇒ |m_last|` — so it ALWAYS contains every one of
+    that CoR's move names. Taken literally, the "OR the CoR's own derived chain"
+    escape hatch means a well-formed bundle can NEVER hard-fail. That is by design
+    for the seed/proof bundles, whose ACs (their real attention atoms) legitimately
+    do NOT re-list every CoR move — failing them would be wrong. So:
+
+      - DEFAULT (`strict=False`): the escape hatch is ON. A move grounded by a real
+        bundle AC is clean; a move grounded ONLY by its CoR's own derived chain is
+        a WARNING ("declared but not wired to an attention chain"); a move grounded
+        by NEITHER is a hard VIOLATION (only reachable via a structurally broken
+        spec). This is the "weaken to a warning and SAY SO" mode.
+
+      - STRICT (`strict=True`): the escape hatch is OFF. A move must be a focus in
+        a real bundle AC or it is a VIOLATION. This is the teeth: it fires on any
+        bundle whose CoR is not actually wired to its attention chains.
+
+    Returns `(violations, warnings)` — lists of human-readable strings.
+    """
+    ac_foci = _focus_set(list(bundle.acs))
+    violations: list[str] = []
+    warnings: list[str] = []
+    for cor in bundle.cors:
+        own_foci = _focus_set([cor_chain(cor)])
+        for move in cor.moves:
+            n = move.name
+            if n in ac_foci:
+                continue  # grounded by a real bundle AC — fully wired
+            if strict:
+                violations.append(
+                    f"{cor.name}.{n}: CoR move is not a focus in any bundle AC (strict)")
+            elif n in own_foci:
+                warnings.append(
+                    f"{cor.name}.{n}: grounded only by the CoR's own derived chain, "
+                    "not surfaced as a focus in any bundle AC")
+            else:
+                violations.append(
+                    f"{cor.name}.{n}: move appears in neither the bundle ACs nor the "
+                    "CoR's own derived chain (structurally broken)")
+    return violations, warnings
+
+
+# ── forge ────────────────────────────────────────────────────────────────────
+@dataclass
+class ForgedBundle:
+    """The compiled artifacts of a persona bundle."""
+    bundle: PersonaBundle
+    ac_languages: list[ACLanguage]      # one forged AC language per bundle AC (via ACCC)
+    personas: list[Persona]             # one forged persona per CoR (via CORCC)
+    uses_violations: list[str] = field(default_factory=list)
+    uses_warnings: list[str] = field(default_factory=list)
+    notation_issues: list[str] = field(default_factory=list)  # includes any melted chain-block issues
+    block_warnings: list[str] = field(default_factory=list)    # prose (unsyntactified) blocks — tolerated
+
+    @property
+    def name(self) -> str:
+        return self.bundle.name
+
+    @property
+    def clean(self) -> bool:
+        return not self.notation_issues and not self.uses_violations
+
+
+def forge_bundle(bundle: PersonaBundle, *, db: str, strict_uses: bool = False) -> ForgedBundle:
+    """Forge a persona bundle: forge each AC via ACCC, forge each CoR via CORCC.
+
+    - Each AC string is forged into its own `accc` Language (ACCC → the `ac:` kind).
+    - Each CoR (`corcc.PersonaSpec`) is forged into a `corcc.Persona` (which itself
+      forges the CoR's inner attention chain — CORCC composes ACCC).
+    - The bundle is linted (`lint`) for notation validity and gated by `uses_them`
+      for the "…that uses them" clause.
+
+    `strict_uses` selects the `uses_them` mode (see its docstring). This never
+    raises on a lint failure — it records the issues on the `ForgedBundle` so the
+    caller decides; that mirrors the other *CC (lint reports, it does not throw).
+    """
+    notation_issues = lint(bundle)                 # already includes melted chain-block issues
+    _block_issues, block_warnings = lint_blocks(bundle)  # recover the prose-block warnings
+    ac_languages = [
+        ac_forge(f"{slugify(bundle.name)}-ac{i}", [ac], db=db)
+        for i, ac in enumerate(bundle.acs)
+    ]
+    personas = [forge_persona(cor, db=db) for cor in bundle.cors]
+    violations, warnings = uses_them(bundle, strict=strict_uses)
+    return ForgedBundle(
+        bundle=bundle, ac_languages=ac_languages, personas=personas,
+        uses_violations=violations, uses_warnings=warnings, notation_issues=notation_issues,
+        block_warnings=block_warnings,
+    )
+
+
+def _safe_prime(persona: Persona) -> str:
+    """CORCC's persona PRIME, with a cue-free fallback.
+
+    Some CoR specs recovered from the proof GBAs have no per-move `cues` persisted
+    (the original build scripts weren't retained — honest under-specification, not
+    invented). CORCC's cue-based paragraph skeleton can't render those, so fall
+    back to a cue-free prime (inner chain + the ordered moves)."""
+    try:
+        return cor_prime(persona)
+    except Exception:
+        spec = persona.spec
+        moves = " → ".join(m.name for m in spec.moves)
+        return "\n".join([
+            f'# PRIME — persona "{spec.name}"',
+            f"({spec.blurb})" if spec.blurb else "",
+            "",
+            "## Inner attention chain (use silently)",
+            inner_template(persona),
+            "",
+            "## Chain-of-reasoning moves (perform in order; the last is the held convergence)",
+            moves,
+            "",
+            "_(per-move cue phrases were not persisted for this recovered persona.)_",
+        ])
+
+
+# ── render / package ─────────────────────────────────────────────────────────
+def render_blocks(bundle: PersonaBundle) -> str:
+    """The description blocks rendered as markdown sections (one `##` per block)."""
+    out: list[str] = []
+    for b in bundle.blocks:
+        title = b.kind.replace("_", " ").strip().title()
+        out.append(f"## {title}")
+        out.append("")
+        out.append(b.body.strip())
+        out.append("")
+    return "\n".join(out).strip()
+
+
+def role_block(bundle: PersonaBundle) -> str | None:
+    """Assemble a CLAUDE.md-ready role block from the description blocks.
+
+    Returns None when the bundle carries no blocks (a degenerate persona whose
+    identity is its CoR — `make_gba` then derives the role from the persona moves).
+    """
+    if not bundle.blocks:
+        return None
+    header = f"# {bundle.name}"
+    if bundle.blurb:
+        header += f"\n\n{bundle.blurb}"
+    body = render_blocks(bundle)
+    return f"{header}\n\n{body}".strip()
+
+
+def package(bundle: PersonaBundle, out_dir: str, *, db: str | None = None,
+            description: str | None = None) -> Path:
+    """Compile the persona bundle to a publishable `<name>/SKILL.md` package.
+
+    The body renders: the description blocks as sections + the AC set + each CoR's
+    re-injectable PRIME (from CORCC). Written via `chaincompiler.write_skill`.
+    A `db` is needed to forge each CoR's prime; if omitted a temp DB is used.
+    """
+    desc = description or (
+        f"Persona (blocks + attention chains + chain-of-reasoning): {bundle.blurb}."
+        if bundle.blurb else f"Persona bundle {bundle.name}."
+    )
+
+    def _build(db_path: str) -> str:
+        personas = [forge_persona(cor, db=db_path) for cor in bundle.cors]
+        parts: list[str] = [
+            "This is a **persona** — a set of DESCRIPTION BLOCKS, a set of ATTENTION CHAINS "
+            "(how to think), and one or more CHAINS OF REASONING (spoken, ending in a decision) "
+            "that use them. Adopt the blocks; think along the attention chains; perform the CoR.",
+            "",
+        ]
+        blocks_md = render_blocks(bundle)
+        if blocks_md:
+            parts += ["# Description blocks", "", blocks_md, ""]
+        parts += ["# Attention chains (how to think — silent templates)", ""]
+        if bundle.acs:
+            parts.append("```rune")
+            parts += [ac.strip() for ac in bundle.acs]
+            parts.append("```")
+        else:
+            parts.append("_(none — this persona's chains are carried by its CoR)_")
+        parts.append("")
+        parts += ["# Chains of reasoning (spoken; you MUST perform these, in order)", ""]
+        for p in personas:
+            parts.append(_safe_prime(p))
+            parts.append("")
+        return "\n".join(parts).rstrip()
+
+    if db is None:
+        with tempfile.TemporaryDirectory() as tmp:
+            body = _build(str(Path(tmp) / "personacc.db"))
+    else:
+        body = _build(db)
+    return write_skill(bundle.name, desc, body, out_dir=out_dir, extra={"kind": "persona-bundle"})
+
+
+# ── seat — the make_gba seam ─────────────────────────────────────────────────
+def seat(bundle: PersonaBundle) -> dict:
+    """Return exactly the kwargs `chainaios.make_gba(domain, root, **seat(bundle))` accepts.
+
+        {
+          "atoms":      list(bundle.acs),   # the attention chains become the GBA's atoms
+          "blurb":      bundle.blurb,
+          "role_block": role_block(bundle), # rendered from the description blocks (or None)
+          "persona":    bundle.cors[0],     # the first CoR is seated as the GBA's CoR
+        }
+
+    FUTURE WORK: only `cors[0]` is seated. A GBA seats exactly one CoR persona
+    today (the melt-gauge is one ordered move-chain), so multi-CoR bundles have
+    their remaining CoRs compiled into the SKILL.md by `package` but not seated.
+    Seating additional CoRs (e.g. as sub-personas / a routed ensemble) is future
+    work — it needs a `make_gba` that carries more than one persona seam.
+    """
+    return {
+        "atoms": list(bundle.acs),
+        "blurb": bundle.blurb,
+        "role_block": role_block(bundle),
+        "persona": bundle.cors[0],
+    }

personacc-0.3.0/src/personacc/notation.py

@@ -0,0 +1,129 @@
+"""PersonaCC notation — the PersonaBundle: what a persona actually IS.
+
+THE RATIFIED DEFINITION (the author):
+
+    a persona = a specific set of DESCRIPTION BLOCKS
+              + a set of ACs (attention chains)
+              + at least one CoR that USES them.
+
+PersonaCC is the SYNTAX compiler for that bundle. Its source language is the 2023
+SDNA-template block grammar: a persona prompt is a stack of `[KIND] … [/KIND]`
+DESCRIPTION BLOCKS (role, description, approach, wrapper, invocation-terms, …)
+wrapped around a reasoning core. Here that core is made rigorous: the reasoning
+core is one-or-more `corcc.PersonaSpec` CoRs, each grounded in a set of `accc`
+attention chains.
+
+Two atoms compose UP into a bundle:
+  - `Block`         — one description block. `kind` is a free string; NEW block
+                      kinds are legal by design (the template-template rule: the
+                      block grammar is extensible, not a closed enum).
+  - `PersonaBundle` — the whole persona: blocks + ACs + ≥1 CoR + a blurb.
+
+Note on the type below CORCC's `PersonaSpec`: that type is really the *COR SPEC*
+(a half-persona — the spoken reasoning move-chain only). PersonaCC does NOT rename
+it; it builds the FULL persona ABOVE it, adding the description blocks and the
+attention chains the CoR is meant to use.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from accc import parse_ac  # accc's REAL chain parser — used for the honest is_chain check
+from corcc.notation import PersonaSpec  # NOTE: really the COR SPEC (half-persona). Do not rename.
+
+
+@dataclass(frozen=True)
+class Block:
+    """One description block of a persona prompt (an SDNA-template block).
+
+    TYPE ⊥ SYNTAX (the author's law): a block is really a triple — (type-`kind`, `lang`,
+    `body` string). The TYPE (what the block IS, e.g. "wrapper") is orthogonal to the
+    SYNTAX it is rendered in; the same block type renders differently in different
+    chain LANGUAGES (one uses only `⇒`, another `-> * + =` in sequence). The `body`
+    string is one RENDER of the canonical typed content in a chosen language.
+
+    - `kind` is a FREE STRING (e.g. "role", "description", "approach", "wrapper",
+      "invocation_terms" — or anything new). New kinds are legal by design; the
+      block grammar is a template-template, so it never closes over a fixed enum.
+    - `lang` names the chain language the `body` is written in. "rune" (the default)
+      is the honeyc Dense Rune-Chain that accc parses/gates. Other languages are
+      lintable only once a gate is registered for them (`forge.register_lang_gate`).
+    - `body` is the block's string (a chain in `lang`, or — soup-grade — prose).
+    """
+    kind: str
+    body: str
+    lang: str = "rune"
+
+    def __post_init__(self) -> None:
+        if not self.kind or not self.kind.strip():
+            raise ValueError("Block.kind must be a non-empty string")
+
+    @property
+    def is_chain(self) -> bool:
+        """True iff this block's body is a conformant chain IN ITS OWN `lang`.
+
+        Keyed to `lang`:
+          - "rune" — HONEST DETECTION via accc's REAL parser (not a regex). accc
+            exposes `parse_ac`, which runs the HoneyC parser and raises unless the
+            body contains a well-formed attention chain (`[Focus] ⇒ … ⇒ |Held|`).
+            That clean parse-check exists, so we use it directly; the
+            forge-in-a-throwaway-db fallback is NOT needed and is deliberately not
+            used. (Broad `except` because a non-chain body can trip the parser with
+            parser-internal errors, not only ValueError.)
+          - any OTHER lang — we cannot parse an arbitrary language, so it is a chain
+            iff a gate is REGISTERED for that lang (an unknown language is unlintable
+            = soup-grade). The gate itself (the melt-gauge) runs later in
+            `forge.lint_blocks`.
+        """
+        if self.lang == "rune":
+            try:
+                parse_ac(self.body)
+                return True
+            except Exception:
+                return False
+        from .forge import LANG_GATES  # lazy: forge imports notation; avoid a cycle
+        return self.lang in LANG_GATES
+
+    @property
+    def grade(self) -> str:
+        """The syntaxification grade of this block:
+
+        - "chain" — the body is real chain syntax in its `lang` (code-grade; melt-gaugeable).
+        - "prose" — free natural language / an unlintable language (soup-grade; TOLERATED
+          for migration only).
+
+        This is the TOTAL-SYNTAXIFICATION gauge at the block level: every persona block
+        should eventually grade "chain" (one notation all the way down); NL is licensed
+        only as a component the syntax admits, never as a free-standing block.
+        """
+        return "chain" if self.is_chain else "prose"
+
+
+@dataclass(frozen=True)
+class PersonaBundle:
+    """A persona: DESCRIPTION BLOCKS + ACs + ≥1 CoR that uses them.
+
+    - `name`   : the persona's name (also the SKILL.md slug).
+    - `blocks` : the description blocks (may be empty for a degenerate persona
+                 whose identity is carried entirely by its CoR — e.g. the seeds).
+    - `acs`    : attention-chain strings in the shared Dense-Rune notation
+                 (`[Focus] ⇒ [Focus] ⇒ |Held|`), each parseable by `accc`.
+    - `cors`   : one or more `corcc.PersonaSpec` CoRs. ≥1 is REQUIRED — a persona
+                 with no reasoning core is not a persona.
+    - `blurb`  : one-line description.
+    """
+    name: str
+    blocks: tuple[Block, ...]
+    acs: tuple[str, ...]
+    cors: tuple[PersonaSpec, ...]
+    blurb: str = ""
+
+    def __post_init__(self) -> None:
+        if not self.cors:
+            raise ValueError(
+                f"PersonaBundle {self.name!r} needs ≥1 CoR — a persona = description "
+                "blocks + ACs + at least one CoR that uses them (the ratified definition)."
+            )
+
+    def block_kinds(self) -> tuple[str, ...]:
+        return tuple(b.kind for b in self.blocks)

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

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: personacc
+Version: 0.3.0
+Summary: Persona Compiler-Compiler — compiles a persona bundle (description blocks + attention chains + ≥1 chain-of-reasoning that uses them) and seats it into make_gba
+Requires-Python: >=3.11
+Requires-Dist: chaincompiler-accc==0.3.0
+Requires-Dist: corcc==0.3.0
+Requires-Dist: chaincompiler==0.3.0

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

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/personacc/__init__.py
+src/personacc/forge.py
+src/personacc/notation.py
+src/personacc.egg-info/PKG-INFO
+src/personacc.egg-info/SOURCES.txt
+src/personacc.egg-info/dependency_links.txt
+src/personacc.egg-info/requires.txt
+src/personacc.egg-info/top_level.txt
+tests/test_personacc.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,3 @@
+chaincompiler-accc==0.3.0
+corcc==0.3.0
+chaincompiler==0.3.0

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

@@ -0,0 +1 @@
+personacc

personacc-0.3.0/tests/test_personacc.py

@@ -0,0 +1,142 @@
+"""PersonaCC tests: bundle validity, the uses-them lint, notation lint, package, seat.
+
+Self-contained — uses corcc seed CoRs (no personapack dependency). The
+"passes on BODHISATTVA" half of the uses-them requirement is tested in
+personapack (where BODHISATTVA lives)."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from corcc import cor_chain
+from corcc.notation import EINSTEIN, BANDIT
+
+import personacc as pc
+from personacc import Block, PersonaBundle
+
+
+# ── a helper: a well-wired bundle whose acs = the CoR's own derived chain ──────
+def _wired(spec=EINSTEIN, blocks=()):
+    return PersonaBundle(name=spec.name, blocks=blocks, acs=(cor_chain(spec),),
+                         cors=(spec,), blurb=spec.blurb)
+
+
+def test_bundle_requires_at_least_one_cor():
+    with pytest.raises(ValueError):
+        PersonaBundle(name="Empty", blocks=(), acs=("[A] ⇒ [B] ⇒ |C|",), cors=(), blurb="")
+
+
+def test_block_kind_is_extensible():
+    # ANY kind string is legal (the template-template rule) — no closed enum.
+    b = Block(kind="a-brand-new-kind", body="hi")
+    assert b.kind == "a-brand-new-kind"
+    with pytest.raises(ValueError):
+        Block(kind="  ", body="x")
+
+
+def test_blocks_render_as_sections():
+    bundle = _wired(blocks=(Block("role", "You are X."), Block("invocation_terms", "a · b")))
+    md = pc.render_blocks(bundle)
+    assert "## Role" in md and "You are X." in md
+    assert "## Invocation Terms" in md and "a · b" in md
+    rb = pc.role_block(bundle)
+    assert rb is not None and "# ThinkLikeEinstein" in rb
+
+
+def test_role_block_none_when_no_blocks():
+    assert pc.role_block(_wired(blocks=())) is None
+
+
+def test_notation_lint_catches_malformed_ac():
+    good = _wired()
+    assert pc.lint(good) == []
+    broken = PersonaBundle(name="Bad", blocks=(), acs=("this is not a rune chain",),
+                           cors=(BANDIT,), blurb="")
+    issues = pc.lint(broken)
+    assert issues, "a malformed AC string should be flagged by the notation lint"
+
+
+def test_uses_them_clean_when_acs_cover_moves():
+    # acs = the CoR's own derived chain -> every move is a focus in a real AC.
+    v, w = pc.uses_them(_wired())
+    assert v == [] and w == []
+
+
+def test_uses_them_fires_on_deliberately_broken_bundle():
+    # acs do NOT cover the CoR's moves -> strict fires as VIOLATIONS, default as WARNINGS.
+    broken = PersonaBundle(name="Broken", blocks=(),
+                           acs=("[Alpha] ⇒ [Beta] ⇒ |Gamma|",), cors=(EINSTEIN,), blurb="")
+    v_strict, _ = pc.uses_them(broken, strict=True)
+    assert v_strict, "strict uses-them must fire on a CoR not wired to any AC"
+    v_default, w_default = pc.uses_them(broken)              # weakened mode
+    assert v_default == [] and w_default, "default mode reports warnings, not violations"
+
+
+def test_package_writes_skill_md(tmp_path: Path):
+    path = pc.package(_wired(blocks=(Block("role", "You are Einstein."),)), out_dir=str(tmp_path))
+    assert path.name == "SKILL.md"
+    text = path.read_text()
+    assert "persona-bundle" in text                 # frontmatter kind
+    assert "Attention chains" in text               # the AC set section
+    assert "PRIME" in text                          # each CoR's prime is rendered
+    assert cor_chain(EINSTEIN) in text              # the CoR chain is present
+
+
+def test_seat_returns_make_gba_kwargs():
+    kw = pc.seat(_wired(blocks=(Block("role", "You are Einstein."),)))
+    assert set(kw) == {"atoms", "blurb", "role_block", "persona"}
+    assert kw["atoms"] == [cor_chain(EINSTEIN)]
+    assert kw["persona"] is EINSTEIN
+    assert kw["role_block"] is not None
+
+
+# ── block grades + the block melt-gauge (TOTAL SYNTAXIFICATION) ────────────────
+def test_block_grades_chain_and_prose():
+    chain = Block("wrapper", "[Output] ⇒ [Adorn] ⇒ |Wrapped|")
+    assert chain.is_chain and chain.grade == "chain"
+    prose = Block("role", "You are a helpful wrapper.")
+    assert not prose.is_chain and prose.grade == "prose"
+
+
+def test_lint_blocks_chain_clean_prose_warns():
+    bundle = _wired(blocks=(Block("wrapper", "[Output] ⇒ [Adorn] ⇒ |Wrapped|"),
+                            Block("role", "You are X.")))
+    issues, warnings = pc.lint_blocks(bundle)
+    assert issues == []                                   # the chain block lints clean
+    assert any("unsyntactified block: role" in w for w in warnings)
+    # a clean chain block + prose warnings ⇒ lint() stays empty (prose is tolerated soup).
+    assert pc.lint(bundle) == []
+
+
+def test_lint_blocks_malformed_chain_fires_gate():
+    bad = _wired(blocks=(Block("wrapper", "[Output] ⇒ [Adorn] this then blah ⇒ |Wrapped|"),))
+    assert bad.blocks[0].grade == "chain"                 # it still parses as a chain…
+    issues, _ = pc.lint_blocks(bad)
+    assert issues, "a malformed chain-block must fire its melt-gauge"
+    assert pc.lint(bad), "…and the melted-block issue folds into lint()"
+
+
+def test_unknown_lang_grades_prose_until_gate_registered():
+    # TYPE ⊥ SYNTAX: an unregistered language is unlintable = soup-grade, until a gate lands.
+    from personacc.forge import LANG_GATES, register_lang_gate
+    b = Block("wrapper", "A -> B -> C", lang="arrowlang")
+    assert b.grade == "prose"                             # no gate registered yet
+    _, warnings = pc.lint_blocks(_wired(blocks=(b,)))
+    assert any("no gate registered for lang=arrowlang" in w for w in warnings)
+    try:
+        register_lang_gate("arrowlang", lambda body: [] if "->" in body else ["missing ->"])
+        assert b.grade == "chain"                         # now lintable ⇒ chain-graded
+        issues, _ = pc.lint_blocks(_wired(blocks=(b,)))
+        assert issues == []                               # "A -> B -> C" contains "->" ⇒ clean
+    finally:
+        LANG_GATES.pop("arrowlang", None)
+
+
+def test_seat_smoke_builds_a_gba(tmp_path: Path):
+    # seat() kwargs actually drive make_gba into a closed GBA (uses EINSTEIN — full cues).
+    from chainaios.gba import make_gba
+    bundle = _wired(blocks=(Block("role", "You are Einstein."),))
+    g = make_gba("physics", tmp_path / "aios", **pc.seat(bundle))
+    assert g.claude_md.exists()
+    assert g.closed